Send videos from any workflow.A real person uploads each one.

# 1. your key (dashboard → API keys → Create key; it is shown once)
export UPLOADLY_KEY="upl_…"

# 2. send a video: a link to the file, the channel, the title, when it goes out
curl -X POST https://uploadly.io/api/v1/videos \
  -H "Authorization: Bearer $UPLOADLY_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "channel": "@deepseafiles",
    "title": "The Deepest Wreck Ever Found",
    "description": "In 2019 a submarine reached…",
    "tags": ["ocean", "shipwreck"],
    "video_url": "https://my-bucket.s3.amazonaws.com/final.mp4?X-Amz-Signature=…",
    "thumbnails": ["https://my-bucket.s3.amazonaws.com/thumb.jpg"],
    "publish": { "at": "17:00" },
    "external_id": "airtable-rec42"
  }'

# 3. read its status (or set a webhook, below)
curl https://uploadly.io/api/v1/videos/vid_3a5dd5bbaeabc46297f9c9a6 -H "Authorization: Bearer $UPLOADLY_KEY"

{
  "id": "vid_3a5dd5bbaeabc46297f9c9a6",
  "external_id": "airtable-rec42",
  "channel": { "id": 12, "name": "Deep Sea Files", "handle": "@deepseafiles" },
  "title": "The Deepest Wreck Ever Found",
  "status": "fetching_file",
  "publish": {
    "mode": "schedule",
    "at": "2026-10-28T16:00:00Z",
    "tz": "Europe/Prague",
    "window": null,
    "from_channel": false,
    "style_fixed": false,
    "deadline": "2026-10-28T14:00:00Z"
  },
  "youtube_url": null,
  "checked": null,
  "problem": null,
  "issues": [],
  "file": { "state": "copying", "name": "video.mp4", "size": null, "received": 0 },
  "thumbnails": [{ "n": 1, "state": "copying" }],
  "created": "2026-10-27T19:04:19Z",
  "updated": "2026-10-27T19:04:19Z"
}

Authorization: Bearer upl_…

{
  "error": "No channel “Ocean” on your account.",
  "code": "unknown_channel",
  "fields": {
    "channel": "No channel “Ocean” on your account.",
    "title": "YouTube does not allow < or > in a title."
  },
  "channels": [
    { "id": 12, "name": "Deep Sea Files", "handle": "@deepseafiles" },
    { "id": 14, "name": "Cold War Stories", "handle": "@coldwarstories" }
  ]
}

# 1. ask for an upload
curl -X POST https://uploadly.io/api/v1/videos -H "Authorization: Bearer $UPLOADLY_KEY" -H "Content-Type: application/json" \
  -d '{"channel": "@deepseafiles", "title": "The Deepest Wreck Ever Found", "file": "upload", "file_name": "final.mp4"}'
# → "upload": { "parts_url": "https://…/api/v1/videos/vid_…/parts/{n}", "complete_url": "https://…/complete", … }

# 2. send the file in 64 MB parts (every part but the last the same size, 5–95 MB)
split -b 64m final.mp4 part_
n=1; for f in part_*; do
  curl -sf -T "$f" -H "Authorization: Bearer $UPLOADLY_KEY" "https://…/api/v1/videos/vid_…/parts/$n" || exit 1
  n=$((n+1))
done

# 3. put it together → status "waiting" (in the queue)
curl -X POST "https://…/api/v1/videos/vid_…/complete" -H "Authorization: Bearer $UPLOADLY_KEY"

curl -X PUT https://uploadly.io/api/v1/videos/vid_…/thumbnails/1 \
  -H "Authorization: Bearer $UPLOADLY_KEY" --data-binary @thumb-a.jpg

{
  "id": "vid_3a5dd5bbaeabc46297f9c9a6",
  "status": "checked",
  "youtube_url": "https://youtu.be/Xb7hGq2LmT0",
  "checked": {
    "public": true,
    "channel_ok": true,
    "title_ok": true,
    "public_at": "2026-10-28T16:00:41Z",
    "at": "2026-10-28T16:10:02Z"
  },
  "problem": null,
  …
}

{
  "channels": [
    {
      "id": 12, "name": "Deep Sea Files", "handle": "@deepseafiles", "yt_id": "UCq1…",
      "publish_style": "by_hand", "publish_time": "17:00",
      "window": { "from": "12:00", "to": "17:00" }, "tz": "Europe/Prague",
      "per_day": 1, "access": "ok", "playlist": null
    }
  ]
}

curl -X PUT https://uploadly.io/api/v1/webhook -H "Authorization: Bearer $UPLOADLY_KEY" \
  -H "Content-Type: application/json" -d '{"url": "https://n8n.example.com/webhook/uploadly"}'
# → { "url": "…", "secret": "whsec_…", "events": [ … ], "shown_once": true }

curl -X POST https://uploadly.io/api/v1/webhook/test -H "Authorization: Bearer $UPLOADLY_KEY"      # a signed "ping" now
curl https://uploadly.io/api/v1/webhook/deliveries -H "Authorization: Bearer $UPLOADLY_KEY"         # what we sent, what you answered

POST /webhook/uploadly HTTP/1.1
Content-Type: application/json
Uploadly-Event: video.live
Uploadly-Delivery: evt_q3Xc1y0bTt9mN2aK
Uploadly-Signature: t=1793289641,v1=5f2b0c9e…a41d

{
  "id": "evt_q3Xc1y0bTt9mN2aK",
  "type": "video.live",
  "created": "2026-10-28T16:00:41Z",
  "data": {
    "video": { "id": "vid_3a5dd5bbaeabc46297f9c9a6", "status": "live", "youtube_url": "https://youtu.be/Xb7hGq2LmT0", … }
  }
}

import crypto from 'node:crypto';
import express from 'express';

// t=<unix>,v1=<hex HMAC-SHA256 of "<t>.<raw body>"> with your whsec_ secret
function verify(secret, rawBody, header, tolerance = 300) {
  const parts = Object.fromEntries(String(header).split(',').map(p => p.split('=')));
  const t = Number(parts.t);
  if (!t || !parts.v1 || Math.abs(Date.now() / 1000 - t) > tolerance) return false;
  const want = crypto.createHmac('sha256', secret).update(`${t}.${rawBody}`).digest('hex');
  return want.length === parts.v1.length && crypto.timingSafeEqual(Buffer.from(want), Buffer.from(parts.v1));
}

const app = express();
// the RAW body: a parsed and re-serialised JSON would not match the signature
app.post('/webhook/uploadly', express.raw({ type: 'application/json' }), (req, res) => {
  if (!verify(process.env.UPLOADLY_WEBHOOK_SECRET, req.body.toString('utf8'), req.get('uploadly-signature'))) {
    return res.sendStatus(400);
  }
  const event = JSON.parse(req.body);
  if (event.type === 'video.live') console.log('Live:', event.data.video.youtube_url);
  res.sendStatus(200);           // answer within 10 s — do slow work after this
});
app.listen(3000);

import hashlib, hmac, json, os, time
from flask import Flask, request, abort

def verify(secret: str, raw_body: bytes, header: str, tolerance: int = 300) -> bool:
    parts = dict(p.split("=", 1) for p in (header or "").split(",") if "=" in p)
    try:
        t = int(parts["t"])
    except (KeyError, ValueError):
        return False
    if abs(time.time() - t) > tolerance:
        return False
    want = hmac.new(secret.encode(), f"{t}.".encode() + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(want, parts.get("v1", ""))

app = Flask(__name__)

@app.post("/webhook/uploadly")
def uploadly():
    # request.get_data(): the raw bytes, exactly as signed
    if not verify(os.environ["UPLOADLY_WEBHOOK_SECRET"], request.get_data(), request.headers.get("Uploadly-Signature")):
        abort(400)
    event = json.loads(request.get_data())
    if event["type"] == "video.problem":
        print("Problem:", event["data"]["video"]["problem"]["message"])
    return "", 200

{
  "channel": "@deepseafiles",
  "title": "{{ $json.title }}",
  "description": "{{ $json.description }}",
  "tags": {{ JSON.stringify($json.tags) }},
  "video_url": "{{ $json.video_url }}",
  "thumbnails": ["{{ $json.thumbnail_url }}"],
  "publish": { "mode": "schedule", "at": "{{ $json.publish_at }}", "tz": "Europe/Prague" },
  "altered_content": true,
  "external_id": "{{ $json.id }}"
}

import os, requests

API = "https://uploadly.io/api/v1"
H = {"Authorization": f"Bearer {os.environ['UPLOADLY_KEY']}"}

# by link: we copy the file ourselves
r = requests.post(f"{API}/videos", headers=H, json={
    "channel": "@deepseafiles",
    "title": "The Deepest Wreck Ever Found",
    "video_url": "https://my-bucket.s3.amazonaws.com/final.mp4?X-Amz-Signature=…",
    "publish": {"mode": "schedule", "at": "2026-10-28T17:00:00", "tz": "Europe/Prague"},
    "external_id": "wreck-001",          # safe to retry: the same id returns the same video
})
if r.status_code == 422:
    print(r.json()["fields"])            # which field, and why
r.raise_for_status()
video = r.json()
print(video["id"], video["status"])

# from a file on this computer: in 64 MB parts
def send_file(path: str, **fields) -> dict:
    v = requests.post(f"{API}/videos", headers=H,
                      json={**fields, "file": "upload", "file_name": os.path.basename(path)}).json()
    up, n = v["upload"], 1
    with open(path, "rb") as f:
        while chunk := f.read(64 * 1024 * 1024):
            requests.put(up["parts_url"].replace("{n}", str(n)), headers=H, data=chunk).raise_for_status()
            n += 1
    return requests.post(up["complete_url"], headers=H).json()

print(send_file("final.mp4", channel="@deepseafiles", title="The Deepest Wreck Ever Found")["status"])   # waiting

import { open } from 'node:fs/promises';
import { basename } from 'node:path';

const API = 'https://uploadly.io/api/v1';
const H = { authorization: `Bearer ${process.env.UPLOADLY_KEY}` };
const PART = 64 * 1024 * 1024;

async function api(method, path, body) {
  const r = await fetch(path.startsWith('http') ? path : API + path, {
    method, headers: body ? { ...H, 'content-type': 'application/json' } : H, body: body && JSON.stringify(body),
  });
  const data = await r.json();
  if (!r.ok) throw Object.assign(new Error(data.error), data);   // data.code, data.fields
  return data;
}

// by link
const video = await api('POST', '/videos', {
  channel: '@deepseafiles', title: 'The Deepest Wreck Ever Found',
  video_url: 'https://my-bucket.s3.amazonaws.com/final.mp4?X-Amz-Signature=…',
  publish: { at: '17:00' }, external_id: 'wreck-001',
});

// from a file, in parts
async function sendFile(file, fields) {
  const v = await api('POST', '/videos', { ...fields, file: 'upload', file_name: basename(file) });
  const fh = await open(file);
  const { size } = await fh.stat();
  for (let n = 1, off = 0; off < size; n++, off += PART) {
    const buf = Buffer.alloc(Math.min(PART, size - off));
    await fh.read(buf, 0, buf.length, off);
    const r = await fetch(v.upload.parts_url.replace('{n}', n), { method: 'PUT', headers: H, body: buf });
    if (!r.ok) throw new Error((await r.json()).error);
  }
  await fh.close();
  return api('POST', v.upload.complete_url);
}

// wait for it (or use a webhook)
for (;;) {
  const v = await api('GET', `/videos/${video.id}`);
  if (['checked', 'problem', 'canceled'].includes(v.status)) { console.log(v.status, v.youtube_url, v.problem); break; }
  await new Promise(r => setTimeout(r, 5 * 60 * 1000));
}