Zum Inhalt springen
LUC·FLOWAPI v1 · Beta

Für Entwickler, Agenturen & Teams

Unsere Pipeline.
Dein Produkt.

Aus einem langen Video werden fertige Shorts — geschnitten, untertitelt, im richtigen Format. Dieselbe Pipeline wie im Studio, angesteuert aus deinem Code oder von deinem KI-Assistenten: Job anlegen, Status abfragen, Clips laden.

  • REST + JSON
  • OpenAPI 3.1
  • MCP-Server
  • In jedem Plan enthalten
Ein Aufruf: Video-Link rein201 Created
POST /api/v1/jobs
Authorization: Bearer lf_…

{ "source_url": "https://www.youtube.com/watch?v=…",
  "options": { "format": "9:16" } }
Einige Minuten später: fertige Clips200 · done
GET /api/v1/jobs/{id}

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

Für wen

Drei Wege, LucFlow einzubauen.

Ob du Kanäle für Kunden betreust, Clipping in dein eigenes Produkt holst oder einen Agenten arbeiten lässt: Der Kern ist derselbe — ein Link rein, fertige Clips raus.

Agenturen & Clipping-Teams

Mehrere Kanäle, ein Konto, ein Guthaben. Jobs aus dem eigenen Tooling anlegen, fertige Clips abholen und im eigenen Ablauf weiterverarbeiten — ohne dass jemand im Studio klickt.

  • Ein Key je Werkzeug, bis zu 5 aktive Keys je Konto
  • Clips ohne Wasserzeichen in jedem bezahlten Plan
  • Sparmodus: nur die Abschnitte bezahlen, die du brauchst

Produkte & Plattformen

Clipping als Funktion in deinem eigenen Produkt: dein Nutzer gibt einen Link, dein Backend ruft LucFlow, die Clips kommen als MP4 zurück. Du behältst Oberfläche und Kunde.

  • REST + JSON, OpenAPI-Spec zum Import und für generierte Clients
  • Formate 9:16, 1:1 und 16:9; eigener Untertitel-Stil per Brand-Kit
  • Status je Job, Clips als Download-Stream mit Titel und Score

Automatisierung & KI-Agenten

Ohne eigenen Code: LucFlow ist ein MCP-Server. Claude, Cursor oder dein eigener Agent legen Jobs an, holen Clips, verschieben geplante Posts — mit denselben Regeln wie im Studio.

  • Werkzeuge für Konto, Jobs, Warteschlange, Kalender und Autopilot
  • n8n, Make oder Zapier sprechen die API über den HTTP-Knoten
  • Nichts wird ohne dich veröffentlicht

Betrieb

Gebaut, um mehr als einen Auftrag zu tragen.

Kundenaufträge laufen auf mehr als einer Maschine. Läuft schon einer, übernimmt die Cloud den nächsten — Aufträge stauen sich nicht hintereinander auf einem Rechner.

Parallel statt nacheinander

Mehrere Aufträge laufen gleichzeitig. Ein langes VOD blockiert nicht den kurzen Clip, der danach kommt.

Eigene Container je Auftrag

In der Cloud bekommt jeder Auftrag getrennte Container für Download, Transkription, Analyse und Render; die Clips eines Auftrags werden parallel gerendert.

Status, den du sehen kannst

Jeder Job meldet Fortschritt, Fehler und Fertigstellung über die API. Den Gesamtbetrieb zeigt die Statusseite — Störungen stehen dort, nicht nur im Discord.

Deckel je Konto — und was darüber geht

3 Aufträge gleichzeitig (Studio und API zusammen), 10 neue Aufträge pro Minute und Key, Tagesbudgets je Plan. Brauchst du mehr, schreib uns mit deinem erwarteten Volumen.

Preise

Dieselben Pläne, kein API-Aufschlag.

Die API kostet nicht mehr als der Plan. 1 Credit = 1 Minute Quellvideo, bei langen Videos mit Längenstaffel darunter — abgebucht erst, wenn der Job fertig ist. Alle Preise brutto, monatlich kündbar.

Starter

19 €/ Monat

180 Credits / Monat

≈ 10,6 ct je Credit

Growth

Beliebt

39 €/ Monat

400 Credits / Monat

≈ 9,8 ct je Credit

Pro

69 €/ Monat

800 Credits / Monat

≈ 8,6 ct je Credit

Zum Testen reicht Free: 50 Credits im Monat, API inklusive, Clips mit LucFlow-Wasserzeichen. Keine Kreditkarte.

Jahresabo: 50 % günstiger — du zahlst 6 von 12 Monaten.

Credits nachkaufen

Einmalkauf, 12 Monate gültig, kein Abo nötig. Für Lastspitzen zwischen zwei Abrechnungen.

  • 100 Credits · 14 €
  • 300 Credits · 36 €
  • 800 Credits · 69 €
  • 1.000 Credits · 99 €
Alle Pläne im Detail →

Mehr Volumen oder ein Team?

Schreib uns, was du vorhast — Aufträge pro Tag, Videolängen, ob du Clips weitergibst. Wir sehen uns deinen Fall an und sagen ehrlich, was heute geht.

Kontakt aufnehmen

In vier Schritten zum Clip.

01

Key erstellen

Im Account unter „API-Keys“ einen Key anlegen (in jedem Plan enthalten). Er wird genau einmal angezeigt — sicher speichern und wie ein Passwort behandeln.

02

Job anlegen

Eine Video-URL (YouTube, Twitch-VOD oder Kick-VOD) per POST einreichen. Die Antwort enthält die Job-ID; die benötigten Credits werden reserviert und erst bei Erfolg abgebucht.

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

Status abfragen

Ein Job braucht einige Minuten (abhängig von Videolänge und Warteschlange). Den Status pollen — z. B. alle 30 Sekunden — bis er auf done steht.

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

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

04

Clips laden

Bei done liefert dieselbe Abfrage die Clip-Liste mit Titel, Länge, Viral-Score und Download-URL pro Clip. Die Dateien bleiben je nach Plan 14–30 Tage verfügbar.

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"

Vollständiges Beispiel.

Job anlegen → pollen → ersten Clip speichern. Key als Umgebungsvariable LUCFLOW_API_KEY setzen, dann kopieren und laufen lassen.

Node.js (18+)
// Als ESM speichern (z. B. clip.mjs) und mit `node clip.mjs` laufen lassen.
import { writeFileSync } from "node:fs";

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

// 1. Job anlegen
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. Pollen, bis der Job fertig ist
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. Ersten Clip speichern
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. Job anlegen
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. Pollen, bis der Job fertig ist
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. Ersten Clip speichern
clip = job["clips"][0]
mp4 = requests.get(clip["download_url"], headers=headers)
open(f'{clip["id"]}.mp4', "wb").write(mp4.content)

Referenz.

Basis-URL https://www.lucflow.de/api/v1 — alle Endpunkte erwarten den Key als Authorization: Bearer lf_… und antworten mit JSON.

POST/jobs

Clipping-Job anlegen. Pflichtfeld source_url; optional webhook_url (HTTPS, Benachrichtigung bei Fertigstellung), ranges als [{start,end}] in Sekunden (Sparmodus: nur diese Abschnitte werden geladen, verarbeitet und abgerechnet) und options mit format (9:16 · 1:1 · 16:9), language (de · en · auto), content_type (gaming · podcast · reallife · auto — auto erkennt den Inhalt worker-seitig per Frame-Analyse), clip_length (auto · short · medium · long · xl) und facecam (auto · yes · no).

GET/jobs

Die letzten 20 eigenen Jobs mit Status und Clip-Anzahl.

GET/jobs/{id}

Status, Fortschritt und — sobald done — die Clip-Liste inkl. Download-URLs.

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

Clip-Datei (MP4) als Download-Stream.

GET/me

Key-Check: aktuelles Credit-Guthaben, Plan und — falls Webhooks aktiv — dein Signatur-Secret (webhook_secret).

GET/insights/channelPro

Die letzten Uploads eines Kanals (url = Kanal-URL, @handle oder ID; count 5–50) mit Ausreißer-Score gegen den eigenen Median — Shorts und Longform getrennt.

GET/insights/videoPro

Öffentliche Kennzahlen eines Videos (url) plus Aufrufe/Stunde, Engagement und Ausreißer-Score gegen die letzten Videos desselben Kanals.

GET/insights/retentionPro

Publikumskurve eines EIGENEN Videos (url) mit den Stellen, an denen Zuschauer hängen bleiben — als Clip-Fenster (clip = Länge in Sekunden), die direkt als ranges in POST /jobs passen.

GET/insights/content-splitPro

Aufrufe eines EIGENEN Kanals (channel_id) getrennt nach Shorts, Longform und Livestream; days = 28, 90, 365 oder all.

GET/insights/statsPro

Aktuelle Zählerstände für bis zu 50 Videos (ids, kommagetrennt) in einem Aufruf — bewusst ohne Cache, um selbst einen Verlauf aufzuzeichnen.

OpenAPI-Spezifikation

Alle Endpunkte, Felder, Wertelisten und Fehlercodes als OpenAPI 3.1 — zum Import in Postman oder Insomnia, für generierte Clients oder zum Weitergeben an einen Agenten. Die Wertelisten kommen aus demselben Code, der die Anfragen prüft.

openapi.json öffnen →

Deine KI steuert LucFlow.

LucFlow ist ein MCP-Server (Model Context Protocol). Verbinde Claude, Cursor oder einen anderen MCP-fähigen Assistenten mit deinem Konto — dann sagst du „mach aus meinem letzten Stream drei Clips“ oder „verschieb den Post von morgen auf Freitag“, und der Assistent erledigt es über dieselbe Pipeline wie das Studio. Endpunkt: https://www.lucflow.de/api/mcp, Auth ist dein API-Key als Bearer.

01

Key erstellen

Im Account unter „API-Keys“ — dort steht auch der fertige Befehl für Claude Code mit deinem Key. Ein Key gehört dir allein: widerrufe ihn dort, wenn du den Zugriff beenden willst.

02

Assistent verbinden

Claude Code und Cursor nehmen die URL plus den Authorization-Header direkt. Claude Desktop und andere Clients ohne Header-Feld gehen über die kleine Brücke mcp-remote (Beispiel unten). Danach erscheinen die LucFlow-Werkzeuge im Assistenten.

Claude Code
claude mcp add --transport http lucflow https://www.lucflow.de/api/mcp \
  --header "Authorization: Bearer lf_YOUR_KEY"
Cursor
// .cursor/mcp.json im Projekt
{
  "mcpServers": {
    "lucflow": {
      "url": "https://www.lucflow.de/api/mcp",
      "headers": { "Authorization": "Bearer lf_YOUR_KEY" }
    }
  }
}
Claude Desktop
// Claude Desktop → claude_desktop_config.json (über die Brücke mcp-remote)
{
  "mcpServers": {
    "lucflow": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://www.lucflow.de/api/mcp",
        "--header", "Authorization: Bearer lf_YOUR_KEY"
      ]
    }
  }
}

03

Loslegen

Der Assistent sieht Guthaben, Jobs, Kalender und Autopiloten deines Kontos. Die Werkzeuge weisen ihn an, vor dem Ausgeben von Credits nachzufragen — und selbst hochladen kann er nichts: posten bleibt dein Klick in der App oder dein Autopilot.

Was der Assistent kann

  • Konto & Guthaben: Plan, Credits, Tageslimits, Credit-Verlauf, verbundene Konten.
  • Clips: Video prüfen und Kosten schätzen, Job anlegen, Status abfragen, laufenden Job abbrechen, Clips mit anklickbarem Download-Link (24 h gültig) holen, letzte Twitch-Streams eines Kanals finden.
  • Kalender: geplante Posts lesen, verschieben (mindestens 5 Minuten voraus), stornieren; veröffentlichte Clips mit Reichweite.
  • Autopilot (Pro, Stream M und Unlimited): Abos lesen, anlegen, ändern, pausieren, fortsetzen, löschen — dieselben Regeln wie im Cockpit.
  • Warteschlange (ab Starter): Links und Playlists mit Kosten-Vorschau einreihen, entfernen, anhalten.
  • Insights (Pro): Kanal-Ausreißer, Video-Kennzahlen, Retention-Kurve mit Clip-Fenstern, Shorts-/Longform-Anteil.

Was er bewusst nicht kann

  • Veröffentlichen. Kein Werkzeug lädt hoch oder plant einen neuen Post — ein Upload ist unwiderruflich, und das bleibt deine Entscheidung in der App. Einzige Ausnahme: ein Autopilot mit Auto-Post postet weiter automatisch — den richtet der Assistent nur auf deine ausdrückliche Bitte ein.
  • Geld. Keine Preise, kein Kauf, kein Abo-Wechsel über den Assistenten.
  • Fremde Daten. Jeder Aufruf läuft unter deinem Key, mit denselben Limits wie im Studio; Analysen gibt es nur für verbundene eigene Kanäle.

Anbindung

Passt in das, was du schon hast.

Kein SDK nötig. Alles, was HTTP spricht, spricht die API.

REST & JSON

Fünf Endpunkte für den Clip-Weg: anlegen, auflisten, abfragen, laden, Key prüfen. Beispiele in curl, Node und Python stehen in der Referenz.

OpenAPI 3.1

Maschinenlesbare Beschreibung unter /api/v1/openapi.json. In Postman oder Insomnia importieren, einen Client generieren, einem Agenten geben.

Spec öffnen →

MCP für KI-Assistenten

Claude Code, Claude Desktop, Cursor und andere MCP-Clients — ein Befehl mit deinem Key, danach stehen die LucFlow-Werkzeuge im Assistenten.

Zur Einrichtung →

n8n, Make, Zapier

Jedes Werkzeug mit HTTP-Knoten reicht: POST /jobs mit dem Link, dann GET /jobs/{id} alle 30 Sekunden, bis status = done. Kein Connector nötig.

Credits & Limits.

  • API-Zugriff ist in jedem Plan enthalten — ohne Aufschlag: die API kostet nicht mehr als der Plan. Nur die Insights-Endpunkte (Kanal- und Video-Analysen) gehören zu Pro, weil sie an einem gemeinsamen YouTube-Kontingent hängen.
  • 1 Credit = 1 Minute Quellvideo — dasselbe Modell wie im Studio, ein gemeinsames Guthaben für beides.
  • Beim Anlegen werden die Credits nur reserviert; abgebucht wird erst, wenn der Job erfolgreich fertig ist. Schlägt er fehl, wird die Reservierung freigegeben.
  • Höchstens 3 gleichzeitig laufende Jobs pro Konto (Studio + API zusammen) und 10 Job-Anfragen pro Minute und Key.
  • Im Free-Plan tragen Clips das LucFlow-Badge — wie im Studio.
  • Quellen: öffentliche YouTube-Videos, Twitch-VODs, Kick-VODs sowie direkte .mp4/.mov-Datei-URLs. Laufende Livestreams werden abgelehnt — erst nach Stream-Ende clippen.

Fehlercodes.

Fehler kommen als { "error": { "code", "message" } } mit passendem HTTP-Status:

unauthorizedKey fehlt, ist ungültig oder widerrufen (401).
unsupported_sourceURL liegt auf keiner unterstützten Plattform (400).
live_url_unsupportedKanal-Link oder noch laufender Stream (400).
insufficient_creditsGuthaben reicht für die Videolänge nicht (402).
too_many_jobsSchon 3 Jobs in Arbeit — warten, bis einer fertig ist (429).
rate_limitedZu viele Anfragen — kurz warten und erneut versuchen (429).

Die vollständige Liste steht in der OpenAPI-Spec.

FAQ

Was Teams vor dem Einbau fragen.

Kann ich die API ohne Abo testen?

Ja. Der Free-Plan enthält 50 Credits im Monat und den API-Zugriff; Clips tragen dort ein LucFlow-Wasserzeichen. Keine Kreditkarte nötig.

Was kostet ein Auftrag?

1 Credit je Minute Quellvideo, bei langen Videos mit Längenstaffel darunter. Die Credits werden beim Anlegen reserviert und erst abgebucht, wenn der Job fertig ist — ein 30-Minuten-Video kostet also höchstens 30 Credits, ein gescheiterter Job nichts.

Wem gehören die fertigen Clips?

LucFlow beansprucht keine Rechte an deinen Clips. Für das Ausgangsmaterial brauchst du die nötigen Rechte — per API genauso wie im Studio; die Details stehen in den AGB.

Wie lange bleiben Clips abrufbar?

14 Tage im Free-Plan, 30 Tage in den bezahlten Plänen, gerechnet ab Anlage des Jobs. Danach werden die Dateien gelöscht — lade sie vorher in dein eigenes System.

Gibt es ein SLA?

Nein, noch nicht. LucFlow ist ein kleines Produkt; den Betrieb zeigt die Statusseite, Störungen stehen dort. Wenn du eine verbindliche Zusage brauchst, sprich uns an, bevor du baust.

Kann ich mehr als 3 Aufträge gleichzeitig laufen lassen?

Der Deckel gilt je Konto und schützt die Warteschlange für alle. Brauchst du mehr, schreib uns mit deinem erwarteten Volumen — wir sehen uns deinen Fall an.

Werden Clips automatisch veröffentlicht?

Nein. Weder die API noch der MCP-Server laden irgendwo hoch. Veröffentlichen bleibt dein Schritt — in der App, in deinem eigenen System oder über einen Autopiloten, den du selbst eingerichtet hast.

Welche Quellen gehen — und kann ich Dateien hochladen?

Öffentliche YouTube-Videos, Twitch- und Kick-VODs sowie direkte .mp4/.mov-Links. Datei-Upload gibt es per API nicht: Leg die Datei auf einen öffentlichen Host und gib den Link an.

Die API ist neu (Beta): Das Antwortformat kann sich in Details noch ändern, bestehende Felder bleiben aber stabil. Fragen oder Wünsche? Melde dich über den Discord-Support unten rechts.