Zum Inhalt springen
LUC·FLOWAPI v1 · Beta

For developers, agencies & teams

Our pipeline.
Your product.

Long videos in, finished shorts out — cut, captioned, in the right format. The same pipeline as the studio, driven from your code or by your AI assistant: create a job, poll its status, download the clips.

  • REST + JSON
  • OpenAPI 3.1
  • MCP server
  • Included in every plan
One call: video link in201 Created
POST /api/v1/jobs
Authorization: Bearer lf_…

{ "source_url": "https://www.youtube.com/watch?v=…",
  "options": { "format": "9:16" } }
A few minutes later: finished clips200 · done
GET /api/v1/jobs/{id}

{ "status": "done",
  "clips": [
    { "title": "…", "duration_sec": 34, "score": 87,
      "download_url": "…/clips/clip_1/download" },
    …
  ] }

Who it's for

Three ways to build LucFlow in.

Whether you run channels for clients, add clipping to your own product or let an agent do the work: the core is the same — a link goes in, finished clips come out.

Agencies & clipping teams

Several channels, one account, one balance. Create jobs from your own tooling, collect the finished clips and continue in your own workflow — nobody has to click through the studio.

  • One key per tool, up to 5 active keys per account
  • Clips without a watermark on every paid plan
  • Saver mode: pay only for the sections you need

Products & platforms

Clipping as a feature of your own product: your user pastes a link, your backend calls LucFlow, the clips come back as MP4. You keep the interface and the customer.

  • REST + JSON, an OpenAPI spec for imports and generated clients
  • Formats 9:16, 1:1 and 16:9; your own caption style via brand kit
  • Status per job, clips as a download stream with title and score

Automation & AI agents

No code of your own: LucFlow is an MCP server. Claude, Cursor or your own agent create jobs, fetch clips and move scheduled posts — under the same rules as the studio.

  • Tools for account, jobs, queue, calendar and autopilot
  • n8n, Make or Zapier talk to the API through their HTTP node
  • Nothing gets published without you

Operations

Built to carry more than one job.

Customer jobs run on more than one machine. If one is already busy, the cloud takes the next — jobs don't pile up behind each other on a single box.

In parallel, not in line

Several jobs run at the same time. A long VOD doesn't block the short clip that comes in after it.

Separate containers per job

In the cloud every job gets its own containers for download, transcription, analysis and rendering; a job's clips are rendered in parallel.

Status you can see

Every job reports progress, errors and completion through the API. The status page shows the overall service — incidents are listed there, not only on Discord.

Caps per account — and beyond

3 jobs at a time (studio and API combined), 10 new jobs per minute per key, daily budgets per plan. Need more? Write to us with your expected volume.

Pricing

Same plans, no API surcharge.

The API costs no more than the plan. 1 credit = 1 minute of source video, with a length discount on long videos — charged only once the job is done. All prices gross, cancel monthly.

Starter

€19/ month

180 credits / month

≈ 10.6 ct per credit

Growth

Popular

€39/ month

400 credits / month

≈ 9.8 ct per credit

Pro

€69/ month

800 credits / month

≈ 8.6 ct per credit

Free is enough to try it: 50 credits a month, API included, clips carry a LucFlow watermark. No credit card.

Yearly plan: 50 % cheaper — you pay 6 of 12 months.

Top up credits

One-off purchase, valid 12 months, no subscription needed. For peaks between two billing cycles.

  • 100 credits · €14
  • 300 credits · €36
  • 800 credits · €69
  • 1,000 credits · €99
All plans in detail →

More volume, or a team?

Tell us what you're planning — jobs per day, video lengths, whether you pass clips on. We'll look at your case and say honestly what works today.

Get in touch

Four steps to a clip.

01

Create a key

In your account under “API keys”, create a key (included in every plan). It is shown exactly once — store it safely and treat it like a password.

02

Create a job

POST a video URL (YouTube, Twitch VOD or Kick VOD). The response contains the job ID; the required credits are reserved and only charged on success.

curl
curl -X POST https://www.lucflow.de/api/v1/jobs \
  -H "Authorization: Bearer lf_DEIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"source_url": "https://www.youtube.com/watch?v=…",
       "options": {"format": "9:16", "content_type": "gaming"}}'

# → {"id": "…", "status": "queued", "reserved_credits": 42, …}

03

Poll the status

A job takes a few minutes (depending on video length and queue). Poll the status — e.g. every 30 seconds — until it reads done.

curl
curl https://www.lucflow.de/api/v1/jobs/JOB_ID \
  -H "Authorization: Bearer lf_DEIN_KEY"

# → {"status": "processing", "progress": 55, …}

04

Download the clips

Once done, the same request returns the clip list with title, length, viral score and a download URL per clip. Files stay available for 14–30 days depending on your plan.

curl
# Sobald status = "done":
# {"clips": [{"id": "clip_1", "title": "…", "score": 87,
#             "download_url": "https://www.lucflow.de/api/v1/jobs/…/download"}]}

curl -OJ CLIP_DOWNLOAD_URL -H "Authorization: Bearer lf_DEIN_KEY"

Full example.

Create a job → poll → save the first clip. Set your key as the environment variable LUCFLOW_API_KEY, then copy and run.

Node.js (18+)
// Save as ESM (e.g. clip.mjs) and run it with `node clip.mjs`.
import { writeFileSync } from "node:fs";

const API = "https://www.lucflow.de/api/v1";
const headers = { Authorization: `Bearer ${process.env.LUCFLOW_API_KEY}` };

// 1. Create the job
const create = await fetch(`${API}/jobs`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    source_url: "https://www.youtube.com/watch?v=…",
    options: { format: "9:16", content_type: "gaming" },
  }),
});
const { id } = await create.json();

// 2. Poll until the job is done
let job;
do {
  await new Promise((r) => setTimeout(r, 30_000));
  job = await (await fetch(`${API}/jobs/${id}`, { headers })).json();
  console.log(job.status, `${job.progress}%`);
} while (job.status === "queued" || job.status === "processing");
if (job.status !== "done") throw new Error(job.error ?? "failed");

// 3. Save the first clip
const clip = job.clips[0];
const res = await fetch(clip.download_url, { headers });
const buf = Buffer.from(await res.arrayBuffer());
writeFileSync(`${clip.id}.mp4`, buf);
Python (requests)
import os, time, requests

API = "https://www.lucflow.de/api/v1"
headers = {"Authorization": f"Bearer {os.environ['LUCFLOW_API_KEY']}"}

# 1. Create the job
r = requests.post(f"{API}/jobs", headers=headers, json={
    "source_url": "https://www.youtube.com/watch?v=…",
    "options": {"format": "9:16", "content_type": "gaming"},
})
job_id = r.json()["id"]

# 2. Poll until the job is done
while True:
    job = requests.get(f"{API}/jobs/{job_id}", headers=headers).json()
    print(job["status"], f'{job["progress"]}%')
    if job["status"] in ("done", "error"):
        break
    time.sleep(30)
if job["status"] != "done":
    raise SystemExit(job.get("error") or "failed")

# 3. Save the first clip
clip = job["clips"][0]
mp4 = requests.get(clip["download_url"], headers=headers)
open(f'{clip["id"]}.mp4', "wb").write(mp4.content)

Reference.

Base URL https://www.lucflow.de/api/v1 — every endpoint expects the key as Authorization: Bearer lf_… and responds with JSON.

POST/jobs

Create a clipping job. Required: source_url; optional webhook_url (HTTPS, notified on completion), ranges as [{start,end}] in seconds (saver mode: only those sections are downloaded, processed and charged) and options with format (9:16 · 1:1 · 16:9), language (de · en · auto), content_type (gaming · podcast · reallife · auto — auto detects the content worker-side via frame analysis), clip_length (auto · short · medium · long · xl) and facecam (auto · yes · no).

GET/jobs

Your 20 most recent jobs with status and clip count.

GET/jobs/{id}

Status, progress and — once done — the clip list incl. download URLs.

GET/jobs/{id}/clips/{clipId}/download

Clip file (MP4) as a download stream.

GET/me

Key check: current credit balance, plan and — if webhooks are enabled — your signing secret (webhook_secret).

GET/insights/channelPro

A channel's latest uploads (url = channel URL, @handle or ID; count 5–50) with an outlier score against its own median — Shorts and longform separately.

GET/insights/videoPro

Public metrics of a video (url) plus views per hour, engagement and an outlier score against the same channel's recent videos.

GET/insights/retentionPro

Audience retention of one of YOUR OWN videos (url) with the moments viewers stick to — as clip windows (clip = length in seconds) that go straight into POST /jobs as ranges.

GET/insights/content-splitPro

Views of YOUR OWN channel (channel_id) split into Shorts, longform and live; days = 28, 90, 365 or all.

GET/insights/statsPro

Current counters for up to 50 videos (ids, comma-separated) in one call — deliberately uncached so you can record your own history.

OpenAPI specification

Every endpoint, field, value list and error code as OpenAPI 3.1 — import it into Postman or Insomnia, generate a client, or hand it to an agent. The value lists come from the same code that validates requests.

Open openapi.json →

Your AI drives LucFlow.

LucFlow is an MCP server (Model Context Protocol). Connect Claude, Cursor or any other MCP-capable assistant to your account — then say “make three clips from my last stream” or “move tomorrow's post to Friday”, and the assistant does it through the same pipeline as the studio. Endpoint: https://www.lucflow.de/api/mcp, auth is your API key as a Bearer token.

01

Create a key

In your account under “API keys” — the ready-made Claude Code command with your key is shown right there. A key is yours alone: revoke it there to end the access.

02

Connect the assistant

Claude Code and Cursor take the URL plus the Authorization header directly. Claude Desktop and other clients without a header field go through the small mcp-remote bridge (example below). The LucFlow tools then show up in the assistant.

Claude Code
claude mcp add --transport http lucflow https://www.lucflow.de/api/mcp \
  --header "Authorization: Bearer lf_YOUR_KEY"
Cursor
// .cursor/mcp.json in your project
{
  "mcpServers": {
    "lucflow": {
      "url": "https://www.lucflow.de/api/mcp",
      "headers": { "Authorization": "Bearer lf_YOUR_KEY" }
    }
  }
}
Claude Desktop
// Claude Desktop → claude_desktop_config.json (via the mcp-remote bridge)
{
  "mcpServers": {
    "lucflow": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://www.lucflow.de/api/mcp",
        "--header", "Authorization: Bearer lf_YOUR_KEY"
      ]
    }
  }
}

03

Go

The assistant sees your balance, jobs, calendar and autopilots. The tools instruct it to ask before spending credits — and it cannot upload anything itself: posting stays your click in the app or your autopilot.

What the assistant can do

  • Account & credits: plan, balance, daily caps, credit history, connected accounts.
  • Clips: check a video and estimate the cost, create a job, poll its status, cancel a running job, fetch clips with a clickable download link (valid 24 h), find a channel's latest Twitch streams.
  • Calendar: read scheduled posts, move them (at least 5 minutes ahead), cancel them; published clips with their reach.
  • Autopilot (Pro, Stream M and Unlimited): read, create, change, pause, resume and delete subscriptions — same rules as the cockpit.
  • Queue (Starter and up): enqueue links and playlists with a cost preview, remove entries, pause.
  • Insights (Pro): channel outliers, video metrics, retention curve with clip windows, Shorts vs. longform split.

What it deliberately cannot do

  • Publish. No tool uploads or schedules a new post — an upload is irreversible, and that stays your decision in the app. The one exception: an autopilot with auto-post keeps posting automatically — the assistant only sets one up when you explicitly ask.
  • Money. No prices, no purchases, no plan changes through the assistant.
  • Other people's data. Every call runs under your key with the same limits as the studio; analytics exist only for your own connected channels.

Integration

Fits what you already run.

No SDK required. Anything that speaks HTTP speaks the API.

REST & JSON

Five endpoints for the clip path: create, list, poll, download, check the key. Examples in curl, Node and Python are in the reference.

OpenAPI 3.1

Machine-readable description at /api/v1/openapi.json. Import it into Postman or Insomnia, generate a client, hand it to an agent.

Open the spec →

MCP for AI assistants

Claude Code, Claude Desktop, Cursor and other MCP clients — one command with your key, then the LucFlow tools show up in the assistant.

Setup →

n8n, Make, Zapier

Any tool with an HTTP node will do: POST /jobs with the link, then GET /jobs/{id} every 30 seconds until status = done. No connector needed.

Credits & limits.

  • API access is included in every plan — no surcharge: the API costs no more than the plan. Only the insights endpoints (channel and video analytics) belong to Pro, because they draw on a shared YouTube quota.
  • 1 credit = 1 minute of source video — the same model as the studio, one shared balance for both.
  • Credits are only reserved when you create a job; they are charged once the job finishes successfully. If it fails, the reservation is released.
  • At most 3 jobs running at the same time per account (studio + API combined) and 10 job requests per minute per key.
  • On the Free plan, clips carry the LucFlow badge — same as in the studio.
  • Sources: public YouTube videos, Twitch VODs, Kick VODs, and direct .mp4/.mov file URLs. Ongoing livestreams are rejected — clip after the stream has ended.

Error codes.

Errors come as { "error": { "code", "message" } } with a matching HTTP status:

unauthorizedKey missing, invalid or revoked (401).
unsupported_sourceURL is not on a supported platform (400).
live_url_unsupportedChannel link or still-running stream (400).
insufficient_creditsBalance doesn't cover the video length (402).
too_many_jobsAlready 3 jobs in flight — wait for one to finish (429).
rate_limitedToo many requests — wait a moment and retry (429).

The complete list is in the OpenAPI spec.

FAQ

What teams ask before they build.

Can I try the API without a subscription?

Yes. The Free plan includes 50 credits a month and API access; clips carry a LucFlow watermark there. No credit card needed.

What does a job cost?

1 credit per minute of source video, with a length discount on long videos. Credits are reserved when you create the job and charged only once it finishes — so a 30-minute video costs at most 30 credits, and a failed job costs nothing.

Who owns the finished clips?

LucFlow claims no rights to your clips. You need the necessary rights to the source material — via the API exactly as in the studio; the details are in the terms.

How long do clips stay available?

14 days on the Free plan, 30 days on paid plans, counted from when the job was created. After that the files are deleted — pull them into your own system before then.

Is there an SLA?

Not yet. LucFlow is a small product; the status page shows the service and lists incidents. If you need a binding commitment, talk to us before you build.

Can I run more than 3 jobs at once?

The cap applies per account and protects the queue for everyone. If you need more, write to us with your expected volume — we'll look at your case.

Are clips published automatically?

No. Neither the API nor the MCP server uploads anywhere. Publishing stays your step — in the app, in your own system, or through an autopilot you set up yourself.

Which sources work — and can I upload files?

Public YouTube videos, Twitch and Kick VODs, and direct .mp4/.mov links. There is no file upload via the API: put the file on a public host and pass the link.

The API is new (beta): response details may still change, but existing fields will stay stable. Questions or requests? Reach us via the Discord support button in the corner.