So nutzt du WizCut

WizCut API

Multicam-Podcast-Schnitt programmatisch steuern: Dateien hochladen, verarbeiten und rendern mit der WizCut API.

Die WizCut API ermöglicht die vollständige Automatisierung des Multicam-Podcast-Schnitts. Du lädst deine Kameraaufnahmen hoch, WizCut erkennt die Sprecher, ermittelt, wer auf welcher Kamera zu sehen ist, und generiert Schnitte. Du kannst sie optional in einem gehosteten Editor prüfen und erhältst anschließend das fertige Video per Webhook.

Die vollständige OpenAPI-3.1-Spezifikation findest du unter https://wizcut.com/openapi.json, gedacht für Codegeneratoren und Agentenplattformen. Soll lieber ChatGPT, Claude oder dein eigener Agent den Schnitt für dich übernehmen? Dann lies WizCut mit ChatGPT, Claude und anderen KI-Agenten nutzen.

Authentifizierung

Erstell einen API-Key unter wizcut.com/settings und füge ihn in jede Anfrage ein:

Authorization: Bearer wc_live_your_key_here

Keys lassen sich jederzeit auf der Einstellungsseite widerrufen.

Job anlegen

POST /api/jobs
{
  "sources": [
    { "label": "Camera 1", "kind": "video", "ext": "mp4", "fileSize": 2147483648 },
    { "label": "Camera 2", "kind": "video", "ext": "mp4", "fileSize": 1932735283 },
    { "label": "Mic mix", "kind": "audio", "ext": "wav" }
  ],
  "callbackUrl": "https://your-server.com/webhook",
  "review": true,
  "autoMap": "confident",
  "silence": { "mode": "tighten" }
}

Felder:

FeldTypBeschreibung
sourcesarrayKamerawinkel oder Audiodateien, bis zu 12 pro Job. Für die Verarbeitung braucht ein Job mindestens zwei Videoquellen. Jeder Eintrag hat ein label, optionales kind ("video" oder "audio", Standard: "video"), optionales ext (mp4, mov, webm, mkv, wav, mp3, m4a oder aac; Standard: "mp4" bei Video, "wav" bei Audio) sowie optionales fileSize: die exakte Dateigröße in Bytes, höchstens 100 GB (107374182400 Bytes) pro Datei.
titlestringOptional. Ein Name für den Job, zum Beispiel der Titel der Folge, bis zu 200 Zeichen. Ohne ihn setzt sich der Titel aus den Quellnamen und dem Datum zusammen.
callbackUrlstringOptional. URL, an die Webhook-Benachrichtigungen gesendet werden, siehe Webhooks.
reviewbooleanStandard: true. Bei true pausiert der Job im Status „ready”, damit ein Mensch die Schnitte vor dem Render prüfen kann. Bei false startet das Rendering automatisch, sobald die Sprecher-Zuordnung abgeschickt wird, egal ob von einem Menschen, von deinem Code oder von WizCut selbst.
autoMapstringStandard: "confident". Legt fest, ob WizCut selbst entscheiden darf, wer auf welcher Kamera zu sehen ist: "off", "confident" oder "always", siehe Automatische Kamerazuordnung.
silenceobjectOptional. Automatisches Entfernen von Pausen, siehe Pausen entfernen. Ohne Angabe ist die Funktion deaktiviert.
sharebooleanStandard: true. Gibt dem fertigen Video eine nicht gelistete Freigabeseite, die jeder mit dem Link öffnen kann, siehe Teilen und Download-Links.

Die Sprecher-Zuordnung (tracks) kannst du hier nicht mitgeben: Source-IDs gibt es erst, nachdem der Job angelegt ist, es gibt also noch nichts, dem sich ein Sprecher zuweisen ließe. Eine tracks-Liste mit Sprechern wird mit 400 und "code": "TRACKS_ON_CREATE" abgelehnt. Nutze autoMap oder ordne die Sprecher per API zu, sobald die Sprechererkennung abgeschlossen ist.

Gib fileSize für jede Datei an, deren Größe du kennst. Dateien über 100 MB bekommen dann einen Multipart-Upload. Damit kannst du Teile parallel hochladen und einzelne Teile wiederholen, und nur so lassen sich Dateien über 5 GB hochladen. Ohne fileSize bekommt jede Datei einen einzelnen presigned PUT, den der Speicher auf 5 GB begrenzt.

fileSize muss exakt stimmen, denn der Wert wird in die Upload-URLs signiert: Ein PUT, dessen Body eine andere Größe hat, wird abgelehnt. Eine Datei über dem Limit weist die API schon vor dem Anlegen des Jobs mit 400 und "code": "FILE_TOO_LARGE" ab. Die Antwort enthält maxBytes, das Limit in Bytes. Ist fileSize keine ganze Zahl an Bytes, lautet der Code "INVALID_FILE_SIZE". Eine Datei, die keine Aufnahme sein kann, weist die API ebenfalls vor dem Anlegen des Jobs ab, mit 422 und "code": "NOT_A_MEDIA_FILE": eine macOS-Metadatei (ein label oder optionaler fileName, der mit ._ beginnt; die echte Datei heißt genauso, nur ohne ._) oder eine fileSize unter 32 KB. Die Antwort nennt die Datei in fileName, den Grund in reason (macos_metadata oder too_small) und ihren sourceIndex.

Antwort:

{
  "jobId": "uuid",
  "uploads": {
    "source-uuid-1": {
      "method": "multipart",
      "uploadId": "...",
      "key": "sources/uuid/source-uuid-1.mp4",
      "partSize": 52428800,
      "partCount": 41,
      "urls": ["https://presigned-part-1-url...", "https://presigned-part-2-url...", "..."]
    },
    "source-uuid-3": {
      "method": "put",
      "url": "https://presigned-upload-url..."
    }
  },
  "audioUploads": { "...": "..." }
}

uploads ist nach den von WizCut vergebenen Source-IDs geschlüsselt, in derselben Reihenfolge wie dein sources-Array. audioUploads kannst du ignorieren. Das Feld nutzen die WizCut-Apps, die vor dem Video schon eine extrahierte Audiospur hochladen.

Sicher wiederholen mit Idempotency-Key

Läuft eine Anfrage in einen Timeout oder bricht die Verbindung ab, weißt du nicht, ob der Job angelegt wurde. Wiederholst du sie blind, entstehen womöglich zwei Jobs. Damit sich Anfragen gefahrlos wiederholen lassen, sende den Header Idempotency-Key mit einem Wert, den du für diesen Job selbst wählst, etwa eine UUID:

curl -s -X POST https://wizcut.com/api/jobs \
  -H "Authorization: Bearer wc_live_your_key" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 5b0d7c1e-8a3f-4f8e-9c51-2f0e6d9b7a14" \
  -d '{ "sources": [...] }'

Der Header ist optional, Anfragen ohne ihn funktionieren wie bisher. Wir empfehlen ihn für Agenten und für alles, was Anfragen selbstständig wiederholt.

  • Gleicher Key, gleicher Body: Du erhältst den Job zurück, den die erste Anfrage angelegt hat, mit derselben jobId und bei Multipart-Uploads auch denselben uploadId, key, partSize und partCount. Alle Upload-URLs sind frisch signiert. Die Antwort enthält den Header Idempotent-Replayed: true. Ein zweiter Job entsteht nicht.
  • Gleicher Key, anderer Body: 422 mit "code": "IDEMPOTENCY_KEY_MISMATCH". Nimm für eine andere Anfrage einen neuen Key. Die Request-Bodys werden als geparstes JSON verglichen, die Reihenfolge der Felder und Leerzeichen spielen also keine Rolle.
  • Die erste Anfrage läuft noch: 409 mit "code": "IDEMPOTENCY_IN_PROGRESS". Warte eine Sekunde und versuch es dann erneut.
  • Der Job wurde inzwischen gelöscht: 409 mit "code": "IDEMPOTENCY_KEY_REUSED". Nimm einen neuen Key.

Ein Key besteht aus 1 bis 255 druckbaren ASCII-Zeichen (alles andere ergibt 400 mit "code": "INVALID_IDEMPOTENCY_KEY"), gehört zu deinem Konto und wird 24 Stunden gespeichert. Eine Anfrage, die schon vor dem Anlegen eines Jobs abgelehnt wird, etwa wegen eines Validierungsfehlers oder weil deine Minuten aufgebraucht sind, verbraucht ihren Key nicht. Du kannst den Fehler beheben und mit demselben Key erneut senden.

Dateien hochladen

Für die presigned URLs ist kein Auth-Header nötig, denn sie authentifizieren sich selbst.

Lade genau die Bytes hoch, die du angegeben hast. HTTP-Clients setzen Content-Length anhand des gesendeten Bodys, du musst den Header also nicht selbst setzen.

"method": "put": die komplette Datei innerhalb einer Stunde per PUT an url senden:

curl -X PUT -T mic-mix.wav "https://presigned-upload-url..."

"method": "multipart": die Datei in partSize große Teile zerlegen (der letzte ist kürzer) und Teil n per PUT an die URL für Teil n senden. Jede Teil-URL akzeptiert nur die exakte Länge ihres Teils, und es gibt genau partCount Teile. Eine höhere Teilnummer wird mit 400 abgelehnt. So gehst du vor:

  1. urls enthält die URLs für die ersten Teile (urls[0] ist Teil 1). Weitere fragst du bei Bedarf nach, bis zu 16 pro Anfrage:

    POST /api/jobs/{jobId}/sources/{sourceId}/parts
    
    { "uploadId": "...", "partNumbers": [5, 6, 7, 8] }
    

    Die Antwort ordnet Teilnummern URLs zu: { "urls": { "5": "https://...", "6": "https://..." } }. Teil-URLs sind zwei Stunden gültig, hol sie dir also erst kurz, bevor du sie brauchst.

  2. Sobald jeder Teil hochgeladen ist, schließt du den Upload ab:

    POST /api/uploads/complete
    
    { "key": "sources/uuid/source-uuid-1.mp4", "uploadId": "..." }
    

Um einen Upload abzubrechen, schick denselben Body an POST /api/uploads/abort.

WizCut prüft die tatsächliche Größe jeder Datei nach dem Upload, beim Abschließen eines Multipart-Uploads und noch einmal beim Start der Verarbeitung. Eine Datei über dem Limit wird gelöscht, und die Anfrage bekommt 400 mit "code": "FILE_TOO_LARGE". Weicht die Größe deutlich von fileSize ab, nach oben wie nach unten, lautet der Code "FILE_SIZE_MISMATCH". Lade die Datei dann erneut für dieselbe Quelle hoch.

Liegen die Aufnahmen schon online, etwa bei Google Drive, Dropbox oder OneDrive, hinter dem Export-Link einer Aufnahmeplattform oder als Anhang in einem Chat mit einem KI-Assistenten, gibst du WizCut einfach den Link, statt die Bytes hochzuladen. WizCut lädt die Datei im Hintergrund herunter.

Leg den Job mit "sources": [] an (oder mit den Dateien, die du hochlädst) und füge danach pro Aufruf eine Datei hinzu:

POST /api/jobs/{jobId}/sources/from-url
{
  "url": "https://drive.google.com/file/d/1AbC.../view?usp=sharing",
  "label": "Camera 1",
  "kind": "video"
}
FeldTypBeschreibung
urlstringEin https://-Link auf eine einzelne Video- oder Audiodatei, bis zu 4096 Zeichen.
labelstringEin Name für die Datei, zum Beispiel "Camera 1" oder "Host mic", bis zu 80 Zeichen.
kindstringOptional: "video" oder "audio". Lässt du es weg, entscheidet WizCut anhand der Datei. Eine Datei ohne Video ist immer eine Audioquelle.

Antwort (202 Accepted):

{ "sourceId": "uuid", "status": "importing" }

Der Aufruf kehrt sofort zurück. Sende wie beim Anlegen eines Jobs einen Idempotency-Key-Header mit, damit eine Wiederholung die Datei nicht doppelt importiert: Derselbe Key mit demselben Body liefert dieselbe sourceId, mit Idempotent-Replayed: true.

Diese Links funktionieren:

  • Direkte Download-Links auf die Datei selbst, darunter signierte Links von Speicherdiensten und der Export-Link einer Aufnahmeplattform, der auf die Datei zeigt.
  • Freigabelinks von Google Drive, Dropbox, OneDrive und SharePoint. Gib sie für „jeden mit dem Link” frei. WizCut macht daraus selbst einen Download, auch aus Drives Hinweis „Diese Datei kann nicht auf Viren überprüft werden” bei großen Dateien.
  • Nicht: Webseiten, Ordner oder Seiten von YouTube, Vimeo, Riverside und Zoom. WizCut liest keine Seiten, um darin ein Video zu finden. Nimm den Download-Link der Plattform oder lade die Datei hoch.

Die Formate sind dieselben wie beim Upload (MP4, MOV, M4A, WebM, MKV, WAV, MP3 und AAC), und WizCut prüft den Inhalt der Datei, nicht ihren Namen. Auch das Limit von 100 GB pro Datei gilt.

Den Import verfolgen. Die Quelle zählt so lange als Upload, bis der Import fertig ist. Die Verarbeitung zu starten beantwortet WizCut in der Zwischenzeit deshalb mit 409 und "code": "SOURCES_PENDING". Die Status-Kurzfassung listet jede Datei unter uploads:

{
  "uploads": {
    "allUploaded": false,
    "files": [
      {
        "sourceId": "uuid",
        "label": "Camera 1",
        "kind": "video",
        "state": "importing",
        "progressPercent": 42,
        "import": {
          "status": "importing",
          "host": "drive.google.com",
          "bytes": 1803886592,
          "totalBytes": 4294967296,
          "error": null
        }
      }
    ]
  }
}

state wechselt von importing zu imported oder zu import_failed, und import.error nennt dann den Grund. WizCut speichert nur den Host des Links, nie den Link selbst.

Schlägt ein Import fehl, läuft der Job weiter. Entferne die Datei und füge stattdessen einen funktionierenden Link oder einen Upload hinzu:

DELETE /api/jobs/{jobId}/sources/{sourceId}

Hat der Job eine callbackUrl, sendet WizCut zusätzlich einen Webhook source_import_failed. Das sind die möglichen Gründe (import.error.code):

CodeBedeutung
URL_NOT_ALLOWEDKein öffentlicher https://-Link: eine private oder lokale Adresse, ein ungewöhnlicher Port oder Benutzername und Passwort im Link.
URL_NOT_REACHABLEDer Server war nicht erreichbar oder hat mit einem Fehler wie 404 geantwortet.
NOT_A_FILEDer Link öffnet eine Webseite oder einen Ordner, keine einzelne Datei.
LOGIN_REQUIREDDer Link verlangt eine Anmeldung. Gib ihn für „jeden mit dem Link” frei.
FILE_TOO_LARGEÜber dem Limit von 100 GB pro Datei.
UNSUPPORTED_MEDIA_FORMATKein unterstütztes Video- oder Audioformat, oder die Datei ist beschädigt.
IMPORT_TIMEOUTDer Download ist stecken geblieben oder hat zu lange gedauert.
IMPORT_FAILEDAuf Seiten von WizCut ist etwas schiefgegangen. Versuch es erneut.

Sofort abgelehnt (es startet kein Import): 400 mit URL_NOT_ALLOWED oder NOT_A_FILE bei Links, die WizCut auch ohne Abruf als falsch erkennt (http://, YouTube). 409 mit INVALID_STATUS, sobald die Verarbeitung gestartet ist, oder mit JOB_FULL bei 12 Dateien. 429 mit TOO_MANY_IMPORTS, wenn im Job schon 6 Importe laufen, oder mit IMPORT_RATE_LIMITED nach 20 Importen in einer Stunde, beide mit einem Retry-After-Header. 503 mit IMPORT_UNAVAILABLE, wenn der Import gerade nicht verfügbar ist.

Du nutzt n8n, Make oder Zapier? Dann ist das der einfachste Weg: keine Dateiverarbeitung, keine Multipart-Uploads. Lege den Job mit einem HTTP-Request-Node an ("sources": []), füge jede Datei mit einem weiteren HTTP-Request-Node hinzu, der auf ihren Drive- oder Dropbox-Link zeigt, und gib pro Datei einen festen Idempotency-Key mit (zum Beispiel die ID der Datei in deinem Drive), damit ein wiederholter Node nicht doppelt importiert. Dann wartest du: Frag GET /api/jobs/{jobId}?view=summary jede Minute ab, bis uploads.allUploaded den Wert true hat, oder reagiere auf den Webhook source_import_failed. Danach startest du die Verarbeitung.

Verarbeitung starten

POST /api/jobs/{jobId}/process

Ruf das erst auf, wenn alle Dateien hochgeladen sind. Der Aufruf startet die Pipeline: Audio-Sync, Sprechererkennung, Proxy-Rendering, Kamerazuordnung und Schnittgenerierung. Die Anfrage kehrt sofort zurück, die Verarbeitung läuft asynchron.

Optionaler Body:

{ "diarizeSourceIds": ["source-uuid-3"] }

diarizeSourceIds legt fest, welche Quellen WizCut für die Sprechererkennung auswertet. Sie sind dein Stimmen-Audio: Auch der Ton der Folge geht von ihnen aus (siehe Audio-Mischung unten). Lässt du das Feld weg, nutzt WizCut deine audio-Quellen oder, falls keine vorhanden sind, die erste Quelle. Wähl die Quellen mit dem saubersten Ton aller Sprecher: Eine Kamera mit stummgeschaltetem oder weit entferntem Mikrofon führt zu einem Job ohne Schnitte.

Du kannst hier auch silence mitschicken, im selben Format wie beim Anlegen des Jobs, etwa wenn die Pauseneinstellung erst nach dem Anlegen feststeht. Ohne Angabe bleibt die Einstellung vom Anlegen. Mit title geht das genauso.

Antwort:

{ "jobId": "uuid", "status": "syncing" }

Jobs auflisten

GET /api/jobs

Liefert { "jobs": [...] } mit deinen 50 neuesten Jobs, die neuesten zuerst. Jeder Job hat id, title, status, thumbnails, created_at und updated_at.

thumbnails enthält pro Kamera ein kleines JPEG-Standbild (320 px breit) als { source_id, url }, in der Reihenfolge der Kameras. Bis die Kamera-Vorschauen fertig sind, ein paar Minuten nach dem Start der Verarbeitung, ist es []. Die URLs sind 6 Stunden lang signiert und ändern sich bei jedem Aufruf. Wenn du die Bilder cachst, dann nach source_id. Für eine Kamera ohne Standbild kommt ein 404 zurück; zeig dann einen Platzhalter.

Job-Status abfragen

GET /api/jobs/{jobId}

Antwort:

{
  "job": {
    "id": "uuid",
    "status": "complete",
    "sources": [...],
    "tracks": [...],
    "turns": [...],
    "cuts": [...],
    "removed_ranges": [...],
    "camera_map": {...},
    "output_url": "https://presigned-download-url...",
    "error_message": null
  },
  "sourceUrls": { "source-uuid-1": "https://..." },
  "audioUrl": "https://...",
  "downloadUrl": "https://wizcut.com/api/jobs/uuid/output",
  "shareUrl": "https://wizcut.com/s/PyuMHl16Tpuhwg1Ob4qbEA1BQblecdp8-ayE20sNcSdQ"
}

Der eigentliche Job steckt unter job. Signierte URLs in der Antwort (output_url, sourceUrls, audioUrl) werden bei jeder Anfrage neu signiert, ruf den Job also lieber erneut ab, statt sie zu speichern. downloadUrl und shareUrl sind die Links, die du speichern kannst, siehe Teilen und Download-Links.

camera_map ist der Vorschlag von WizCut, wer auf welcher Kamera zu sehen ist, siehe Die Camera Map. Bis zur Berechnung ist der Wert null.

Statuswerte:

StatusBedeutung
createdJob angelegt, wartet auf Uploads
uploadingWartet, bis alle Dateien hochgeladen sind (z. B. nachdem ein fehlgeschlagener Job neu gestartet wurde)
syncingAudio-Synchronisation zwischen den Quellen
diarizingSprechererkennung läuft
mappingSprecher erkannt. WizCut ermittelt noch, wer auf welcher Kamera zu sehen ist, oder ein Mensch (bzw. dein Agent) muss die Zuordnung bestätigen
readySchnitte generiert, bereit zur Prüfung oder zum Rendering
renderingFinales Rendering läuft
completeRendering abgeschlossen, output_url verfügbar
approvedAusgabe von einem Menschen bestätigt
failedFehler aufgetreten, Details in error_message

Status-Kurzfassung

Der vollständige Job enthält jeden Redebeitrag und jeden Schnitt und wird dadurch groß. Willst du nur wissen, wo ein Job steht und was als Nächstes ansteht, etwa beim Polling aus einem Agenten oder einer Automatisierung, fordere die Kurzfassung an:

GET /api/jobs/{jobId}?view=summary
{
  "id": "uuid",
  "status": "mapping",
  "progress": null,
  "nextAction": {
    "type": "map_speakers",
    "url": "https://wizcut.com/jobs/uuid/edit?reviewToken=...",
    "message": "Confirm who is on which camera at the review link, or submit the mapping with POST /api/jobs/uuid/tracks."
  },
  "outputUrl": null,
  "downloadUrl": "https://wizcut.com/api/jobs/uuid/output",
  "shareUrl": "https://wizcut.com/s/PyuMHl16Tpuhwg1Ob4qbEA1BQblecdp8-ayE20sNcSdQ",
  "share": true,
  "error": null,
  "failedAtStatus": null,
  "updatedAt": "2026-10-10T09:42:17.000Z",
  "uploads": null,
  "syncWarnings": [],
  "syncRecheck": { "running": false, "failed": false, "available": false }
}

progress ist der Render-Fortschritt von 0 bis 1, solange der Job im Status rendering ist, sonst null. error und failedAtStatus entsprechen dem Webhook „failed”. Solange der Job noch Dateien annimmt (created, uploading), listet uploads jede Datei und ihren Stand auf: uploading oder uploaded, bei Dateien, die per Link importiert werden, auch importing, imported oder import_failed samt Grund. Danach ist der Wert null. nextAction.message ist ein englischer Hinweistext, den du an eine Person oder einen Agenten weiterreichen kannst. Baue deine Logik auf nextAction.type auf:

typeStatusWas zu tun isturl
upload_filescreated, uploading; oder failed, wenn der Upload abgebrochen istDateien hochladen, dann die Verarbeitung starten. Ist der Job fehlgeschlagen, weil der Upload abgebrochen ist (24 Stunden kam nichts an), kann ihn fortsetzen, wer hochgeladen hat: in der WizCut-App mit denselben Dateien. Was angekommen ist, bleibt eine Woche gespeichert.null
waitsyncing, diarizing, renderingNichts zu tun, WizCut arbeitet. Frag später erneut ab oder warte auf den nächsten Webhook.null
map_speakersmappingBestätigen, wer auf welcher Kamera zu sehen ist, im Editor oder per API.Review-Link, wie die reviewUrl im Webhook „mapping”
review_or_renderreadySchnitte prüfen oder das Rendering starten.Review-Link
downloadcomplete, approvedVideo herunterladen.Frisch signierte Render-URL (auch in outputUrl)
retryfailedPOST /api/jobs/{jobId}/retry aufrufen.null
contact_supportfailedEin neuer Versuch hilft nicht, zum Beispiel weil die Datei kein unterstütztes Format hat. Lege einen neuen Job an oder melde dich bei uns.mailto:-Link

Sind die für die Sprechererkennung gewählten Quellen stumm, lautet type zwar retry, ein einfacher neuer Versuch würde aber genauso scheitern. Die Meldung rät dann zu einem Retry mit einer diarizeSourceIds-Liste, die eine Quelle mit klarer Sprache nennt.

Dateien, die WizCut nicht ausrichten konnte. WizCut legt deine Dateien anhand ihres Tons übereinander. Passt der Ton einer Datei zu keiner anderen – oft ein geschnittener oder gekürzter Export statt der Originalaufnahme –, platziert WizCut sie so gut es geht, aber Bild und Ton können darauf versetzt sein. Der Job schlägt deshalb nicht fehl: syncWarnings (in der Zusammenfassung und im vollständigen GET /api/jobs/{jobId}) listet jede dieser Dateien mit sourceId, label, kind und einem reason auf – unverified (platziert, aber nichts hat es bestätigt), not_placed (sie beginnt am Anfang), no_audio (kein Ton zum Ausrichten) oder unreadable (ihr Ton ließ sich nicht lesen, also wurde sie gar nicht geprüft). Auch eine Datei, die gepasst hat, kann drifting sein: Das Gerät, das sie aufgenommen hat, geht minimal anders, sodass sie über die Folge um driftMs (Millisekunden, vom Anfang bis zum Ende) auseinanderläuft. WizCut legt sie in der Mitte passend an, Anfang und Ende sind also je um etwa die Hälfte versetzt; korrigiert wird das noch nicht. Passen alle Dateien, ist es []; die Meldungen zu map_speakers, review_or_render und download nennen die Dateien ebenfalls. Ist die Liste nicht leer, lass einen Menschen vor dem Veröffentlichen die Lippensynchronität prüfen.

Synchronisierung erneut prüfen. Bei einer Datei mit unreadable liest POST /api/jobs/{jobId}/sync-recheck den Ton aller Dateien neu und richtet sie neu aus. Nur die Platzierung ändert sich; Status, Sprecher, Zuordnung und Schnitte bleiben. Die Antwort kommt sofort mit 202, und syncRecheck (in der Zusammenfassung und im vollständigen Job) zeigt den Stand: running, solange geprüft wird (bei großen Dateien ein paar Minuten), failed, wenn die letzte Prüfung nicht fertig wurde, und available, wenn eine Prüfung jetzt helfen kann (eine Datei ist unreadable, der Job ist mapping, ready oder complete, und keine Prüfung läuft). Frag ab, bis running false ist, lies dann syncWarnings neu und rendere erst danach, damit das Video die neue Platzierung verwendet. Ablehnungen: SYNC_RECHECK_NOT_NEEDED und SYNC_RECHECK_RUNNING (beide 409). WizCut startet eine solche Prüfung direkt nach der Synchronisierung schon selbst, sobald eine Datei unreadable ist; meist siehst du also nur, wie running auf false geht. Ruf es selbst auf, wenn diese Prüfung nicht geholfen hat (failed).

Rendern mit Dateien, die nicht ausgerichtet sind. Eine Datei mit not_placed, no_audio oder unreadable liegt am Anfang der Folge und ist im Video deshalb nicht lippensynchron. POST /api/jobs/{jobId}/render lehnt dann mit 409 ab: SYNC_RECHECK_RUNNING, solange eine Prüfung die Dateien noch ausrichtet (ein paar Minuten warten und erneut versuchen), FILES_NOT_SYNCED, wenn nichts sie mehr platzieren wird; files nennt sie. Mit {"allowUnsyncedFiles": true} renderst du trotzdem, sobald eine Person das so entschieden hat; das Video trägt dann die Render-Warnung FILES_NOT_SYNCED. Jobs mit review: false warten auf eine laufende Prüfung, bevor sie von selbst rendern, und rendern mit der Warnung, wenn Dateien danach immer noch nicht ausgerichtet sind.

Renders, die nicht wie gewünscht herauskamen. Selten wird ein Render fertig, kann aber nicht alles umsetzen, was du verlangt hast. Meist ist es einer von zwei Fällen: PROGRAM_AUDIO_FAILED, wenn WizCut den Ton der Folge nicht aus deinen Originaldateien mischen konnte, das Video also die grobe Mischung aus der Sprechererkennung nutzt, ohne deinen Audio-Mix und ohne deine Lautheit; und AV_DRIFT, wenn ein Teil des Videos sichtbar länger oder kürzer geworden ist als geplant, sodass Bild und Ton auseinanderlaufen können. Der Job ist trotzdem „complete”, und renderWarnings (in der Zusammenfassung und im vollen GET /api/jobs/{jobId}) listet, was schiefging, jeweils mit code und einer message, die du einem Menschen zeigen kannst. Die download-Nachricht sagt es auch, und der Webhook „complete” trägt dieselbe Liste als warnings. Lief alles wie gewünscht, ist sie []. Ein neuer Render behebt es meistens. Ein dritter, FILES_NOT_SYNCED, heißt: Es wurde mit allowUnsyncedFiles gerendert, während einige Dateien nicht ausgerichtet waren; rendere neu, sobald sie es sind.

Ein Job lässt sich fünfmal pro Stunde neu versuchen. Ist er nach so vielen Versuchen wieder fehlgeschlagen, antwortet POST /api/jobs/{jobId}/retry mit 429 und "code": "RETRY_LIMIT". retryAfterSeconds (auch im Header Retry-After) sagt dir, wann du es wieder versuchen kannst. Auch andere Ablehnungen tragen einen code: INVALID_STATUS (409, der Job ist nicht failed), NOT_RETRYABLE (422, er ist in einer Phase fehlgeschlagen, die sich nicht neu starten lässt) und INVALID_DIARIZE_SOURCES (400, diarizeSourceIds ist leer oder nennt Quellen, die der Job nicht hat).

Es können neue Typen hinzukommen. Behandle einen unbekannten Typ wie wait. Unbekannte view-Werte liefern den vollständigen Job.

Job löschen

DELETE /api/jobs/{jobId}

Löscht den Job und alle zugehörigen Dateien: Uploads, Proxys, das Audio für die Sprechererkennung und das fertige Video. Funktioniert in jedem Status; läuft gerade noch ein Verarbeitungsschritt, wird dessen Ergebnis entfernt, sobald er fertig ist. Bereits verbrauchte Minuten werden nicht gutgeschrieben. Antwort: { "ok": true }, oder 404, wenn der Job nicht existiert oder nicht dir gehört.

Zu einem fertigen Video gehören drei Links. Wähl den, der zu deinem Vorhaben passt:

FeldGültigkeitWer sie öffnen kannGeeignet für
outputUrlEinige Stunden (eine signierte Datei-URL)Jeder, der sie hatDie Datei sofort an einen anderen Dienst übergeben
downloadUrlSolange der Job existiertDu: mit deinem API-Key oder in einem Browser, in dem du bei WizCut angemeldet bistLinks, die du in deinen eigenen Tools aufbewahrst
shareUrlSolange der Job existiert und die Freigabe aktiv istJeder, der den Link hatDas Video an andere schicken oder einen stabilen Link für Dritte bereitstellen

Alle drei stehen in GET /api/jobs/{jobId} (vollständig und mit ?view=summary) sowie in den Webhooks „complete” und „approved”.

downloadUrl lautet https://wizcut.com/api/jobs/{jobId}/output. Jede Anfrage leitet (302) auf eine frisch signierte Datei-URL weiter, der Link selbst wird also nie ungültig. Sende deinen API-Key mit. Im Browser funktioniert der Link, wenn du angemeldet bist, andernfalls wirst du zuerst zur Anmeldung aufgefordert. Hänge ?download=1 an, damit der Browser die Datei speichert, statt sie abzuspielen. Solange das Rendering nicht abgeschlossen ist, antwortet der Link mit 409 und "code": "NOT_RENDERED".

curl -L -H "Authorization: Bearer $WIZCUT_API_KEY" \
  -o episode.mp4 "https://wizcut.com/api/jobs/$JOB_ID/output"

shareUrl ist eine nicht gelistete Seite (https://wizcut.com/s/…) mit Player, Titel und Download-Button. Ohne den Link findet sie niemand, und Suchmaschinen indexieren sie nicht. Hängst du /video.mp4 an den Link, bekommst du die reine Datei. Solange das Rendering nicht abgeschlossen ist, zeigt die Seite an, dass die Folge noch nicht fertig ist. Du kannst den Link also schon vorher weitergeben.

Die Freigabe ist für neue Jobs standardmäßig aktiv. Schalte sie beim Anlegen mit "share": false ab oder ändere sie später:

PATCH /api/jobs/{jobId}
{ "share": false }
FeldTypBeschreibung
sharebooleanSchaltet die Freigabeseite ein oder aus. Schaltest du sie aus und wieder ein, bekommst du denselben Link zurück.
resetShareLinkbooleanBei true ersetzt ein neuer Link den bisherigen. Der alte Link funktioniert dann dauerhaft nicht mehr. Nutze das, wenn ein Link an einer Stelle gelandet ist, wo er nicht hingehört.

Antwort:

{ "jobId": "uuid", "share": true, "shareUrl": "https://wizcut.com/s/..." }

Solange die Freigabe ausgeschaltet ist, ist shareUrl null. Im WizCut-Editor kannst du die Freigabe unter dem fertigen Video ebenfalls ein- und ausschalten, den Link kopieren oder einen neuen erzeugen.

Die Freigabeseite spielt das Video für jeden ab, der den Link hat. Behandle sie daher wie das Video selbst. Sind in der Folge weitere Personen zu sehen, kläre vorher, ob sie mit dem Teilen einverstanden sind.

Transkript und Untertitel

Folgen mit Transkript haben "hasTranscript": true in GET /api/jobs/{jobId} (vollständig und mit ?view=summary). Wir führen Transkripte schrittweise ein, deshalb haben die meisten Folgen noch keines.

GET /api/jobs/{jobId}/transcript?format=srt
ParameterWerteBeschreibung
formattxt (Standard), srt, vttKlartext mit einem Absatz pro Sprecher, mit Name und Zeit; oder Untertitel als SRT oder WebVTT.
timelineedit (Standard), renderedit folgt dem Schnitt, wie er jetzt ist. render passt zum zuletzt fertigen Video, für Untertitel zu einer Datei, die du schon heruntergeladen hast.
download1Schickt Content-Disposition: attachment, benannt nach dem Titel des Jobs.

Die Antwort ist die Datei selbst, kein JSON. Die Zeiten folgen dem Schnitt: Was aus der Folge geschnitten wurde, fehlt, und alles danach rückt nach vorne, damit die Untertitel zum Video passen. Der Header X-WizCut-Timeline sagt, welchem Schnitt sie folgen; er sagt edit, wenn du render angefragt hast, das Video aber entstand, bevor WizCut festhielt, was ein Render herausschneidet.

curl -H "Authorization: Bearer $WIZCUT_API_KEY" \
  -o folge.srt "https://wizcut.com/api/jobs/$JOB_ID/transcript?format=srt&timeline=render"

Fehler: 404 mit "code": "NO_TRANSCRIPT", wenn die Folge keines hat, 409 mit "code": "INVALID_STATUS", bevor sie geschnitten ist, und 409 mit "code": "NOT_RENDERED" bei timeline=render ohne fertiges Video.

Webhooks

Wenn du eine callbackUrl angibst, sendet WizCut eine JSON-POST-Anfrage, sobald ein Job einen der folgenden Status erreicht. WizCut versucht jede Zustellung bis zu dreimal und wartet jeweils bis zu 10 Sekunden auf eine Antwort deines Endpoints.

Jede Zustellung ist signiert, du kannst also prüfen, ob sie wirklich von WizCut stammt, siehe Webhooks verifizieren. Frag den Status zusätzlich per Polling ab, falls eine Zustellung verloren geht.

Webhook „mapping” (ein Mensch muss bestätigen, wer auf welcher Kamera zu sehen ist):

{
  "jobId": "uuid",
  "status": "mapping",
  "reviewUrl": "https://wizcut.com/jobs/uuid/edit?reviewToken=...",
  "speakers": ["SPEAKER_00", "SPEAKER_01"],
  "cameraMap": {
    "version": 1,
    "speakers": ["SPEAKER_00", "SPEAKER_01"],
    "unassignedSpeakers": ["SPEAKER_01"],
    "droppedSpeakers": [],
    "cameras": [
      { "sourceId": "source-uuid-1", "kind": "closeup", "confidence": "high", "speakers": ["SPEAKER_00"], "...": "..." },
      { "sourceId": "source-uuid-2", "kind": "closeup", "confidence": "low", "speakers": ["SPEAKER_01"], "...": "..." }
    ]
  }
}

Schick einen Menschen zur reviewUrl, um Sprecher den Kameraquellen zuzuordnen und die Schnitte zu prüfen, oder ordne sie per API zu. Review-Links sind 72 Stunden gültig. speakers listet die erkannten Sprecher auf, der gesprächigste zuerst.

cameraMap ist der Vorschlag von WizCut, im selben Format wie camera_map am Job, siehe Die Camera Map. Gibt es noch keinen Vorschlag, fehlt das Feld.

Wann dieser Webhook eintrifft, hängt von autoMap ab:

  • "confident" oder "always": Der Job bleibt ohne Webhook im Status „mapping”, während WizCut die Kameras ermittelt. Das dauert wenige Minuten, nachdem die Proxys erstellt sind. Danach ordnet WizCut die Kameras entweder selbst zu, und der nächste Webhook ist „ready”, oder es sendet „mapping” samt Vorschlag. Kann WizCut keinen Vorschlag berechnen (zum Beispiel weil ein Proxy fehlgeschlagen ist), kommt „mapping” ohne cameraMap, spätestens etwa 30 Minuten nach der Sprechererkennung.
  • "off": „mapping” kommt direkt nach der Sprechererkennung, in der Regel ohne cameraMap. Der Vorschlag erscheint wenige Minuten später in GET /api/jobs/{jobId}.

Webhook „ready” (Sprecher-Zuordnung abgeschickt, von einem Menschen, deinem Code oder WizCut, und Schnitte generiert):

{
  "jobId": "uuid",
  "status": "ready",
  "reviewUrl": "https://wizcut.com/jobs/uuid/edit?reviewToken=..."
}

Webhook „complete” (Rendering abgeschlossen):

{
  "jobId": "uuid",
  "status": "complete",
  "outputUrl": "https://presigned-download-url...",
  "downloadUrl": "https://wizcut.com/api/jobs/uuid/output",
  "shareUrl": "https://wizcut.com/s/..."
}

Webhook „approved” (Mensch hat die Ausgabe über das Review-UI bestätigt):

{
  "jobId": "uuid",
  "status": "approved",
  "outputUrl": "https://presigned-download-url...",
  "downloadUrl": "https://wizcut.com/api/jobs/uuid/output",
  "shareUrl": "https://wizcut.com/s/..."
}

Webhook „failed” (der Job ist fehlgeschlagen, egal in welcher Phase):

{
  "jobId": "uuid",
  "status": "failed",
  "error": "description of what went wrong",
  "failedAtStatus": "syncing"
}

error enthält dieselbe Meldung, die GET /api/jobs/{jobId} als error_message liefert. failedAtStatus nennt die Phase, in der es schiefging, zum Beispiel syncing, diarizing oder rendering. Bei den meisten Fehlern in Sync, Sprechererkennung und Rendering startet WizCut vorher einmal automatisch einen neuen Versuch. Kommt dieser Webhook, hat also auch der nicht geklappt.

Eine Ausnahme ist eine Datei, die WizCut nicht lesen kann. Jeder Upload wird vor der Verarbeitung geprüft. Alles, was keine MP4-, MOV-, M4A-, WebM-, MKV-, WAV-, MP3- oder AAC-Datei ist, lässt den Job sofort fehlschlagen, egal was die Dateiendung behauptet. Einen neuen Versuch gibt es nicht, denn dieselbe Datei würde genauso scheitern. Das gilt auch für beschädigte oder abgeschnittene Dateien. Der error nennt die Datei über ihr label, zum Beispiel "Camera 2" isn't a supported video or audio format, or the file is damaged. (die API liefert diese Meldung auf Englisch). Lade eine unterstützte Datei in einem neuen Job hoch.

Webhook „source_import_failed” (eine Datei, die du per Link hinzugefügt hast, ließ sich nicht importieren):

{
  "jobId": "uuid",
  "status": "source_import_failed",
  "sourceId": "source-uuid-1",
  "code": "LOGIN_REQUIRED",
  "error": "That link needs a sign-in. Make the file viewable by anyone with the link, or use a direct download link."
}

Dieser Webhook betrifft eine einzelne Datei, nicht den Job: Der Job bleibt in seinem Status. Entferne die Quelle mit DELETE /api/jobs/{jobId}/sources/{sourceId} und füge einen funktionierenden Link oder einen Upload hinzu. code ist einer der Fehlercodes beim Import. Für erfolgreiche Importe gibt es keinen Webhook, schau dazu in die Status-Kurzfassung.

Die outputUrl in den Webhooks „complete” und „approved” ist sieben Tage nach Abschluss des Renderings gültig. GET /api/jobs/{jobId} liefert dagegen immer eine frisch signierte output_url. Willst du einen Link aufbewahren, speichere stattdessen downloadUrl oder shareUrl (shareUrl ist null, wenn die Freigabe ausgeschaltet ist), siehe Teilen und Download-Links.

Webhooks verifizieren

WizCut signiert jeden Webhook nach der Spezifikation Standard Webhooks, die offiziellen standardwebhooks-Bibliotheken können die Prüfung also für dich übernehmen. Jede Zustellung trägt drei Header:

HeaderWert
webhook-idPro Event eindeutig, etwa msg_2b6f0c…. Eine Wiederholung desselben Events trägt dieselbe ID, damit kannst du Duplikate überspringen.
webhook-timestampZeitpunkt dieses Versuchs in Unix-Sekunden.
webhook-signatureEine oder mehrere Signaturen, durch Leerzeichen getrennt, jeweils im Format v1,<base64>.

Dein Signing-Secret findest du auf der Einstellungsseite unter „Webhook-Signaturschlüssel”. Er sieht aus wie whsec_… und gilt für alle deine Jobs.

Jede Signatur ist der Base64-kodierte HMAC-SHA256 über {webhook-id}.{webhook-timestamp}.{body}, berechnet mit den Bytes deines Secrets als Schlüssel: dem Teil nach whsec_, Base64-dekodiert. So prüfst du eine Zustellung:

  1. Berechne die Signatur über den rohen Request-Body, genau so, wie er angekommen ist, nicht über JSON, das du geparst und wieder serialisiert hast.
  2. Akzeptiere die Zustellung, wenn irgendeine v1-Signatur im Header übereinstimmt. Vergleiche dabei in konstanter Zeit.
  3. Lehne Zeitstempel ab, die mehr als 5 Minuten von deiner Uhr abweichen, damit sich eine abgefangene Zustellung nicht später erneut einspielen lässt.
  4. Merk dir die webhook-ids, die du schon verarbeitet hast, und überspringe Wiederholungen.

Mit dem Paket standardwebhooks (Node):

import express from "express";
import { Webhook } from "standardwebhooks";

const wh = new Webhook(process.env.WIZCUT_WEBHOOK_SECRET); // "whsec_..."
const app = express();

// express.raw: Die Signatur deckt den Body genau so ab, wie er gesendet wurde
app.post("/webhook", express.raw({ type: "application/json" }), (req, res) => {
  let event;
  try {
    // Prüft die Signatur und das 5-Minuten-Zeitfenster, wirft bei einem Fehler eine Exception
    event = wh.verify(req.body.toString("utf8"), req.headers);
  } catch {
    return res.status(400).send("Invalid signature");
  }
  // event.jobId, event.status, ...
  res.sendStatus(200);
});

Mit reinem crypto (Node):

import crypto from "node:crypto";

function verifyWizCutWebhook(rawBody, headers, secret) {
  const id = headers["webhook-id"];
  const timestamp = headers["webhook-timestamp"];
  const signatures = headers["webhook-signature"];
  if (!id || !timestamp || !signatures) return false;

  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 5 * 60) return false;

  const key = Buffer.from(secret.slice("whsec_".length), "base64");
  const expected = crypto
    .createHmac("sha256", key)
    .update(`${id}.${timestamp}.${rawBody}`)
    .digest();

  return signatures.split(" ").some((entry) => {
    const [version, signature] = entry.split(",");
    if (version !== "v1" || !signature) return false;
    const received = Buffer.from(signature, "base64");
    return (
      received.length === expected.length &&
      crypto.timingSafeEqual(received, expected)
    );
  });
}

Python:

import base64
import hashlib
import hmac
import time

def verify_wizcut_webhook(raw_body: bytes, headers, secret: str) -> bool:
    msg_id = headers.get("webhook-id")
    timestamp = headers.get("webhook-timestamp")
    signatures = headers.get("webhook-signature")
    if not (msg_id and timestamp and signatures):
        return False

    if abs(time.time() - int(timestamp)) > 5 * 60:
        return False

    key = base64.b64decode(secret.removeprefix("whsec_"))
    signed = f"{msg_id}.{timestamp}.".encode() + raw_body
    expected = base64.b64encode(hmac.new(key, signed, hashlib.sha256).digest()).decode()

    for entry in signatures.split(" "):
        version, _, signature = entry.partition(",")
        if version == "v1" and hmac.compare_digest(signature, expected):
            return True
    return False

Secret rotieren. „Neuen Schlüssel erstellen” auf der Einstellungsseite erzeugt ein neues Secret. Das alte funktioniert noch 24 Stunden weiter. In dieser Zeit trägt jede Zustellung zwei Signaturen, die neue zuerst, dein Server kann also mit dem Secret prüfen, das er gerade kennt. Tausche das neue Secret innerhalb dieser 24 Stunden ein. Rotierst du erneut, bevor die 24 Stunden um sind, verliert das älteste Secret sofort seine Gültigkeit, denn nur das aktuelle und das vorherige Secret signieren.

Kann WizCut eine Zustellung einmal nicht signieren, sendet es sie trotzdem, nur ohne Signatur-Header, statt sie zu verwerfen. Ob du eine unsignierte Zustellung akzeptierst, entscheidest du. Lehnst du sie ab, ruf den Job per GET /api/jobs/{jobId} ab, um zu sehen, was sich geändert hat.

Sprecher-Zuordnung und Prüfung (Human-in-the-loop)

Nach der Sprechererkennung wechselt der Job in den Status „mapping”. Die erkannten Sprecher müssen den Kameraquellen zugeordnet werden, denn die Sprechererkennung bestimmt zwar, wann jemand spricht, aber nicht, auf welcher Kamera die Person zu sehen ist.

WizCut versucht, diese Zuordnung für dich zu ermitteln. Menschen bewegen sich beim Sprechen: Sie gestikulieren, nicken, lehnen sich vor. WizCut vergleicht daher das Sprechen jedes Sprechers mit der Bewegung auf jeder Kamera und schlägt vor, wer auf welcher zu sehen ist. Wie viel WizCut davon allein entscheidet, bestimmst du mit autoMap.

Wird ein Mensch gebraucht, sendet WizCut den Webhook „mapping”. Er enthält eine reviewUrl, einen signierten Link zum WizCut-Editor. Schick einen Menschen dorthin. Im Editor nimmt er folgende Schritte vor:

  1. Prüfen, welcher Sprecher auf welcher Kamera zu sehen ist (Kameras, bei denen sich WizCut sicher ist, sind bereits ausgewählt)
  2. Die automatisch generierten Schnitte in der Vorschau prüfen und bearbeiten
  3. Auf „Render” klicken, wenn alles stimmt (bei review: true, dem Standard)
  4. Optional auf „Approve” klicken, nachdem die gerenderte Ausgabe geprüft wurde

Bei review: false startet das Rendering automatisch, sobald die Sprecher-Zuordnung abgeschickt wird. Eine Prüfung der Schnitte vor dem Render entfällt.

Automatische Kamerazuordnung

Setze autoMap, wenn du den Job anlegst:

ModusWas WizCut tutSinnvoll, wenn
"off"Ordnet die Kameras nie selbst zu. Sendet „mapping” direkt nach der Sprechererkennung. Der Vorschlag erscheint wenige Minuten später am Job und kann von einem Menschen oder deinem Agenten genutzt werden.Ohnehin immer ein Mensch die Zuordnung prüft.
"confident"Standard. Ordnet die Kameras selbst zu, wenn es sicher ist, für jeden Sprecher eine Nahaufnahme gefunden zu haben, und geht dann weiter zu „ready”. Andernfalls sendet es „mapping” mit angehängtem Vorschlag. Eine Totale oder Zweiereinstellung wird im Schnitt verwendet, zählt aber nie als eigene Kamera eines Sprechers.In den meisten Integrationen. Du hörst nur von WizCut, wenn es Hilfe braucht.
"always"Wartet nicht auf einen Menschen. Nutzt zuerst die Antworten, bei denen es sich sicher ist, dann die wahrscheinlichen, und verteilt übrige Sprecher nach Redezeit auf die verbleibenden Kameras. Nur wenn es gar keinen Vorschlag berechnen kann (zum Beispiel weil ein Proxy fehlgeschlagen ist), sendet es „mapping”.Vollautomatische Pipelines, die lieber einen geschätzten Schnitt bekommen als einen hängenden Job.

„Bei jedem Sprecher sicher” heißt: Jeder Sprecher mit mindestens einer Minute Sprechzeit ist auf einer Kamera, die WizCut mit high Konfidenz beantwortet hat. Kameras, bei denen sich WizCut unsicher ist, bekommen keine Sprecher, der Schnitt wechselt also nicht zu ihnen. Willst du sie trotzdem nutzen, korrigier das im Editor.

Rechne damit, dass „confident” ziemlich oft einen Menschen hinzuzieht. Bei Material, in dem die Bewegung keinem einzelnen Sprecher folgt, hält es sich zurück: TV-Studios mit geschalteten Feeds, Events, Handkameras oder bediente Kameras. Außerdem braucht es etwa 20 Minuten Gespräch, um sicher zu sein, kurze Clips landen deshalb meist in „mapping”. In unseren bisherigen Tests hat WizCut keinen Sprecher auf die falsche Kamera gelegt, wenn es sich sicher war, die Stichprobe ist aber noch klein.

In Kombination mit review: false bedeuten "confident" und "always", dass ein Job gerendert werden kann, ohne dass ihn jemand ansieht. Das ist bei vollautomatischen Pipelines der Sinn der Sache. Soll ein Mensch jeden Schnitt sehen, lass review: true stehen.

Die Camera Map

Der Vorschlag liegt am Job als camera_map (im Webhook „mapping” als cameraMap). Bis zur Berechnung, wenige Minuten nach dem Erstellen der Proxys, ist er null. Hier ein Beispiel für eine Show mit zwei Personen, einer Nahaufnahme pro Person und einer Zweiereinstellung:

{
  "version": 1,
  "computedAt": "2026-10-01T09:42:17.000Z",
  "speakers": ["SPEAKER_00", "SPEAKER_01"],
  "unassignedSpeakers": [],
  "droppedSpeakers": ["SPEAKER_02"],
  "cameras": [
    {
      "sourceId": "source-uuid-1",
      "kind": "closeup",
      "confidence": "high",
      "speakers": ["SPEAKER_00"],
      "z": { "SPEAKER_00": 11.5, "SPEAKER_01": 0.9 },
      "lagErrorS": { "SPEAKER_00": 0.1, "SPEAKER_01": 41.6 }
    },
    {
      "sourceId": "source-uuid-2",
      "kind": "closeup",
      "confidence": "high",
      "speakers": ["SPEAKER_01"],
      "z": { "SPEAKER_01": 12.4, "SPEAKER_00": 1.3 },
      "lagErrorS": { "SPEAKER_01": 0.2, "SPEAKER_00": 63.0 }
    },
    {
      "sourceId": "source-uuid-3",
      "kind": "twoshot",
      "confidence": "high",
      "speakers": ["SPEAKER_01", "SPEAKER_00"],
      "positions": { "left": "SPEAKER_01", "right": "SPEAKER_00" },
      "z": { "SPEAKER_00": 6.8, "SPEAKER_01": 5.2 },
      "lagErrorS": { "SPEAKER_00": 0.3, "SPEAKER_01": 0.4 }
    }
  ]
}

Pro Kamera:

FeldBeschreibung
sourceIdEine der Videoquellen des Jobs.
kindWas die Kamera zeigt: closeup (eine Person), twoshot (zwei Personen nebeneinander), wide (drei Personen), multi (mehrere Personen nacheinander, meist eine bediente oder geschaltete Kamera) oder unknown.
confidencehigh (WizCut ist sicher), low (eine wahrscheinliche, aber nicht sichere Antwort) oder none (keine Antwort).
speakersWer auf der Kamera zu sehen ist. Leer, wenn confidence den Wert none hat. Bei Zweiereinstellungen und Totalen von links nach rechts.
positionsNur bei Zweiereinstellungen und Totalen: wer links (left), in der Mitte (middle) und rechts (right) im Bild sitzt.
reasonHat den Wert no_motion, wenn eine Kamera gar nicht analysiert werden konnte.
z, lagErrorSDiagnosewerte pro Sprecher: wie stark die Bewegung der Kamera dem Sprechen dieser Person folgt und um wie viele Sekunden der beste Treffer danebenlag. Nützlich zur Fehlersuche, aber keine Grundlage, auf die du aufbauen solltest.

Oberste Ebene:

FeldBeschreibung
speakersDie Sprecher, die WizCut bewertet hat: alle mit mindestens einer Minute Sprechzeit.
unassignedSpeakersBewertete Sprecher, die auf keiner high-Kamera zu sehen sind. Ist die Liste nicht leer, überlässt „confident” die Entscheidung einem Menschen.
droppedSpeakersSprecher mit zu wenig Sprechzeit für eine Bewertung, meist ein verirrtes Label oder ein kurzer Einwurf. WizCut legt sie auf keine Kamera.

Um den Vorschlag unverändert zu übernehmen, machst du aus jeder Kamera, der du vertraust, einen Track aus sourceId und speakers und schickst ihn ab.

Sprecher per API zuordnen

Wenn du ohnehin weißt, wer vor welcher Kamera sitzt, oder dein Agent den Vorschlag geprüft hat, kannst du die Zuordnung selbst übernehmen, solange der Job im Status „mapping” ist:

POST /api/jobs/{jobId}/tracks
{
  "tracks": [
    { "sourceId": "source-uuid-1", "speakers": ["SPEAKER_00"] },
    { "sourceId": "source-uuid-2", "speakers": ["SPEAKER_01"] }
  ]
}

Nutz die Sprechernamen aus dem Webhook „mapping” (oder die turns aus GET /api/jobs/{jobId}) zusammen mit deinen Video-Source-IDs. Eine Kamera kann mehrere Sprecher zeigen. WizCut generiert daraufhin die Schnitte, versetzt den Job in den Status „ready”, sendet den Webhook „ready” und startet bei review: false den Render. Die Antwort enthält die neuen cuts.

Jede sourceId muss eine der Videoquellen des Jobs sein, andernfalls antwortet die API mit 400 und "code": "UNKNOWN_SOURCE". Du kannst die Zuordnung auch abschicken, während WizCut die Kameras noch ermittelt: Wer zuerst kommt, gewinnt. Wurde die Zuordnung bereits abgeschickt, zum Beispiel automatisch, erhältst du 409 mit "code": "INVALID_STATUS".

Fortgeschritten: Zuordnung korrigieren, nachdem Schnitte existieren. Sobald der Job „ready” oder „complete” ist, kann derselbe Endpunkt die Zuordnung weiterhin ändern, generiert aber keine Schnitte mehr für dich: Sende die korrigierten cuts zusammen mit tracks (und optional removedRanges), sonst erhältst du 400 mit "code": "CUTS_REQUIRED". WizCut speichert beides gemeinsam, ein späterer Recut nutzt also die korrigierte Zuordnung. Liegt ein Stück eines Schnitts außerhalb der Datei seiner Kamera (weil sie später beginnt oder früher endet), wandert es auf eine Kamera, die dort Material hat. Die cuts in der Antwort sind das, was gespeichert wurde. Es wird kein Webhook gesendet und kein Render gestartet. Löse einen aus, wenn du eine neue Ausgabe brauchst. Der WizCut-Editor erledigt das alles selbst, wenn dort jemand eine Zuordnung korrigiert.

Pausen entfernen

WizCut kann lange Pausen automatisch straffen oder entfernen, bevor die Schnitte generiert werden. Das passiert zuerst, damit die Kamerawechsel auf dem bereits gestrafften Gespräch entschieden werden. So bekommst du nie einen Schnitt auf eine Kamera, die sofort den Großteil ihrer Bildzeit an eine entfernte Pause verliert.

Aktivieren lässt sich das über das silence-Feld beim Anlegen eines Jobs:

{ "silence": { "mode": "tighten" } }

Modi:

ModusVerhalten
offAlle Pausen bleiben wie aufgenommen erhalten (Standard, wenn silence weggelassen wird).
tightenLange Pausen werden auf einen natürlichen Beat gekürzt (~0,7 s). Empfohlen: Das Gespräch bleibt menschlich.
removeLange Pausen werden fast vollständig herausgeschnitten, nur so viel Padding bleibt, dass keine Wörter abgeschnitten werden.

Optionale Feinjustierung (die Standardwerte funktionieren für die meisten Aufnahmen gut):

FeldStandardBereichBeschreibung
minPauseSec1.50.3–10Nur Pausen, die länger sind, werden bearbeitet.
keepPauseSec0.70–3Der Beat, der anstelle einer gestrafften Pause stehen bleibt (nur im Modus tighten).
paddingSec0.250–1Sicherheitsabstand, der bei jedem entfernten Bereich um die Sprache herum erhalten bleibt.

Die Erkennung arbeitet konservativ: Eine Pause wird nur entfernt, wenn sowohl die Sprechererkennung als auch eine Audio-Energieanalyse übereinstimmend „still” ergeben. Lachen und andere nicht-sprachliche Momente bleiben dadurch erhalten.

Das Job-Objekt (GET /api/jobs/{jobId}) enthält neben cuts auch removed_ranges: die entfernten Bereiche in der Quellzeit als { startMs, endMs }. Das finale Rendering überspringt diese Bereiche, im Review-Editor erscheinen sie als wiederherstellbare, schraffierte Abschnitte.

Nachträglich ändern lässt sich das über den Recut-Endpunkt:

POST /api/jobs/{jobId}/recut
{ "silence": { "mode": "remove", "minPauseSec": 1.0 } }

Recut generiert Schnitte und entfernte Bereiche aus den bereits erkannten Sprechern neu, ohne erneute Verarbeitung. Die Antwort kommt daher sofort zurück, mit den neuen Werten für cuts, removedRanges und savedMs (wie viel kürzer die Ausgabe dadurch wird). Übergib { "mode": "off" }, um die Stille-Entfernung wieder zu deaktivieren. Lässt du silence ganz weg, bleibt die gespeicherte Einstellung des Jobs erhalten. Mit dem Schnitttempo ist es genauso: Gib "presetId" an ("relaxed", "balanced" oder "dynamic"), um es zu ändern, oder lass es weg, dann behält der Job sein aktuelles Tempo.

Hinweis zur Abrechnung: Die Nutzung wird in Input-Minuten gemessen (dem hochgeladenen Material). Die Stille-Entfernung ändert also nichts an den Kosten eines Jobs, sie macht nur die Ausgabe kompakter.

Erweitert: Schnitte programmatisch steuern

Für vollständig automatisierte Pipelines, die das UI komplett umgehen, lässt du WizCut die Kameras zuordnen oder ordnest Sprecher per API zu und steuerst Schnitte und Rendering danach selbst. Diese Endpunkte funktionieren, solange der Job im Status „ready” oder „complete” ist:

Schnitte aktualisieren:

PATCH /api/jobs/{jobId}/cuts
{
  "cuts": [
    { "startMs": 0, "endMs": 5000, "sourceId": "source-uuid-1" },
    { "startMs": 5000, "endMs": 12000, "sourceId": "source-uuid-2" }
  ]
}

Derselbe Endpunkt akzeptiert außerdem removedRanges (ein Array aus { startMs, endMs }), um die Stille-Entfernungs-Bereiche direkt zu bearbeiten, zum Beispiel um eine Pause wiederherzustellen, die der automatische Durchlauf entfernt hat. Du kannst cuts, removedRanges oder beides senden.

Jeder Schnitt muss eine der Videoquellen des Jobs nennen, also eine Kamera. Eine Audiodatei hat kein Bild: Ein Schnitt darauf bekommt einen 422 mit "code": "CUT_NOT_ON_CAMERA", die betroffenen IDs stehen in sourceIds. Audiodateien landen trotzdem im Ton der Folge.

Render auslösen:

POST /api/jobs/{jobId}/render

Funktioniert aus dem Status „ready” heraus oder aus „complete”, um nach dem Bearbeiten der Schnitte erneut zu rendern. Liefert { "jobId": "uuid", "status": "rendering" } zurück, oder einen 409 mit "code": "NO_CUTS", wenn der Job keine Schnitte zum Rendern hat, oder "code": "NO_CAMERA", wenn nur noch Audiodateien übrig sind.

Ausgabe bestätigen:

POST /api/jobs/{jobId}/approve

Funktioniert nur, wenn der Job bereits „complete” ist. Setzt ihn auf „approved” und sendet den Webhook „approved”.

Audio

WizCut mischt den Ton aus deinen Original-Audiodateien in voller Qualität. Standardmäßig nimmt es die Dateien, die du für die Sprechererkennung ausgewählt hast, so wie sie aufgenommen wurden. Zwei Dinge ändern das.

Lautheit. Gib beim Rendern loudness mit:

POST /api/jobs/{jobId}/render
{ "loudness": "podcast" }

"original" lässt den Pegel wie aufgenommen (Standard), "podcast" bringt die Folge auf −16 LUFS, "youtube" auf −14 LUFS, jeweils mit Spitzen unter −1 dBTP. Das ist eine Verstärkung für die ganze Folge, leise und laute Stellen bleiben also im Verhältnis. Ohne das Feld bleibt die letzte Wahl des Jobs. Um die Wahl ohne Render festzulegen, schick { "loudness": "podcast" } an PUT /api/jobs/{jobId}/audio-mix (unten); der Editor macht das, sobald du einen Pegel auswählst. output_loudness am Job sagt, wie laut der letzte Render geworden ist.

Die Mischung. Abfragen mit:

GET /api/jobs/{jobId}/audio-mix
{
  "jobId": "uuid",
  "audioMix": {
    "balance": true,
    "duck": { "enabled": true, "depthDb": -12, "fadeMs": 150, "padMs": 250 },
    "tracks": {}
  },
  "tracks": [
    {
      "sourceId": "source-uuid-3",
      "label": "guest-mic.wav",
      "hasAudio": true,
      "inMix": true,
      "loudnessLufs": -26.9,
      "balanceDb": 5.5,
      "levelDb": 0,
      "gainDb": 5.5,
      "speaker": "SPEAKER_01",
      "speakerChosen": false,
      "centered": false,
      "role": { "kind": "own", "speakers": ["SPEAKER_01"], "speechToNoiseDb": 31 }
    }
  ],
  "speakers": [{ "label": "SPEAKER_01", "name": "Maya" }],
  "canBalance": true,
  "canDuck": true,
  "loudness": { "target": "original", "lastRender": null },
  "usingDefault": false,
  "defaultMix": { "sourceIds": ["source-uuid-3"], "duck": false, "reason": "picks" }
}

tracks zeigt jede Datei so, wie der nächste Render sie abspielt: ob sie in der Mischung ist und ihr endgültiges gainDb (balanceDb aus „Stimmen angleichen“ plus dein eigenes levelDb). speaker sagt, wessen Mikro es ist. Das ermittelt WizCut nach der Sprechererkennung aus den Pegeln. centered ist true, wenn links und rechts in einer Datei unterschiedlicher Ton war (ein Mikro nur auf einer Seite oder je eins pro Seite): Dann spielt WizCut beide Kanäle auf beiden Seiten, damit niemand nur auf einem Ohr zu hören ist. Das wird bei der Verarbeitung automatisch gesetzt.

role sagt, was die Datei hört, ermittelt aus ihren Pegeln nach der Sprechererkennung: own (das Mikro einer Person, für sie mindestens 6 dB lauter als für alle anderen), group (ein paar Personen etwa gleich laut) oder everyone (ein Raummikro oder eine Totale). Ein speechToNoiseDb unter 15 klingt verrauscht. Solange du nichts einstellst (usingDefault), gilt defaultMix, nach Rolle gewählt: das eigene Mikro jeder Person, eins pro Person, aus all deinen Dateien, heruntergeregelt zwischen den Wortbeiträgen (ownMics); sonst, aus deinen diarizeSourceIds, wenn jede Auswahl alle hört, die sauberste allein (cleanest); sonst deine Auswahl, wie sie ist (picks). Eine Spur, die du bei einem PUT in tracks weglässt, geht auf diesen Standard zurück.

Ändern mit:

PUT /api/jobs/{jobId}/audio-mix
{
  "balance": true,
  "duck": { "enabled": true },
  "tracks": {
    "source-uuid-3": { "gainDb": 2, "muted": false },
    "source-uuid-4": { "gainDb": 0, "muted": false, "speaker": null }
  }
}

Es ändert sich nur, was du mitschickst. duck wird Feld für Feld übernommen; tracks ersetzt die ganze Liste pro Spur, schick also jede Spur mit, die du gesetzt haben willst.

FeldWirkung
balanceStimmen angleichen: hebt leisere Mikros auf den Pegel des lautesten (eine Verstärkung pro Spur, höchstens +18 dB).
duck.enabledZieht jedes Mikro runter, solange seine Person nicht spricht, damit die anderen Stimmen, die es mit aufnimmt, die Mischung nicht hohl klingen lassen. Feinjustierung über depthDb (−40 bis −3, Standard −12), fadeMs (20–1000, Standard 150) und padMs (0–1000, Standard 250: wie früh es vor dem Einsatz aufgeht).
tracks.<sourceId>.gainDbDein Pegel für diese Datei, −24 bis +12 dB, zusätzlich zu „Stimmen angleichen“.
tracks.<sourceId>.mutedtrue nimmt die Datei aus dem Ton.
tracks.<sourceId>.speakerWessen Mikro es ist: ein Sprecher-Label, oder null für niemandes (Raummikro oder Kamera, wird nie runtergezogen). Weglassen, um WizCuts Schätzung zu nehmen.

Funktioniert in jedem Status. Die Mischung gilt für den nächsten Render; ruf den Render-Endpunkt also noch mal auf, um sie im Video zu hören. Ein fehlerhaftes Feld oder ein speaker, den es in der Folge nicht gibt, liefert 400 mit "code": "INVALID_AUDIO_MIX".

Fehlerantworten

Alle Endpunkte liefern Fehler in diesem Format:

{ "error": "Description of what went wrong" }

Manche Fehler enthalten zusätzlich einen maschinenlesbaren code:

CodeHTTPBedeutung
TRACKS_ON_CREATE400POST /api/jobs hat eine Sprecher-Zuordnung erhalten. Lass tracks weg und nutze autoMap, oder setze die Zuordnung später.
FILE_TOO_LARGE400Eine Datei überschreitet das Größenlimit, entweder in fileSize angegeben oder erst nach dem Upload festgestellt. maxBytes nennt das Limit.
INVALID_FILE_SIZE400fileSize ist keine ganze Zahl an Bytes.
NOT_A_MEDIA_FILE422Eine Datei kann keine Aufnahme sein: eine macOS-Metadatei (der Name beginnt mit ._) oder eine fileSize unter 32 KB. fileName und reason sagen, welche und warum. Schick die Kamera- und Audiodateien selbst.
FILE_SIZE_MISMATCH400Die hochgeladene Datei ist deutlich kleiner oder größer als ihr fileSize. Lade sie erneut hoch.
UNKNOWN_SOURCE400Ein Track nennt eine sourceId, die keine Videoquelle des Jobs ist.
CUTS_REQUIRED400Wer die Zuordnung ändert, nachdem Schnitte existieren, muss auch die aktualisierten cuts mitsenden.
CUT_NOT_ON_CAMERA422Ein Schnitt nennt etwas, das keine Videoquelle des Jobs ist, etwa eine Audiodatei (kein Bild). sourceIds listet sie auf.
NOT_ENOUGH_VIDEOS400Für die Verarbeitung braucht der Job mindestens zwei Videoquellen.
EMPTY_MAPPING400Die Sprecher-Zuordnung setzt niemanden auf eine Kamera. Ordne mindestens einen Sprecher zu.
INVALID_IDEMPOTENCY_KEY400Der Header Idempotency-Key besteht nicht aus 1 bis 255 druckbaren ASCII-Zeichen.
URL_NOT_ALLOWED400Import per Link: kein öffentlicher https://-Link.
NOT_A_FILE400Import per Link: eine YouTube- oder Vimeo-Seite, keine Datei.
QUOTA_EXCEEDED403Deine Minuten sind aufgebraucht.
SOURCES_PENDING409/process wurde aufgerufen, während noch Dateien hochladen oder importiert werden, oder der Import einer Datei ist fehlgeschlagen. pendingSourceIds nennt sie (importingSourceIds und importFailedSourceIds zeigen, welche davon Importe sind). Schließ diese Uploads zuerst ab und entferne Dateien, deren Import fehlgeschlagen ist.
INVALID_STATUS409Der Job befindet sich nicht in einem Status, der das erlaubt, zum Beispiel weil seine Zuordnung schon abgeschickt wurde.
NO_CUTS409Es gibt keine Schnitte zum Rendern.
NO_CAMERA409Der Job hat keine Videoquelle mehr, nur Audiodateien, also gibt es kein Bild zum Rendern.
SOURCES_DELETED409Die Originaldateien des Jobs sind gelöscht, weil wir Originale je nach Tarif nur begrenzte Zeit aufbewahren. Öffne den Job im Editor, lade dieselben Dateien erneut hoch und rendere dann.
NOT_RENDERED409Es gibt noch kein fertiges Video. downloadUrl funktioniert, sobald der Job den Status complete oder approved hat.
IDEMPOTENCY_IN_PROGRESS409Eine Anfrage mit demselben Idempotency-Key wird noch verarbeitet. Versuch es gleich noch einmal.
IDEMPOTENCY_KEY_REUSED409Der Job (oder die importierte Datei), den dieser Idempotency-Key angelegt hat, wurde gelöscht. Nimm einen neuen Key.
JOB_FULL409Import per Link: Der Job hat schon 12 Dateien.
IDEMPOTENCY_KEY_MISMATCH422Dieser Idempotency-Key wurde schon mit einem anderen Request-Body verwendet.
TOO_MANY_IMPORTS429Import per Link: In diesem Job laufen schon 6 Importe. Warte, bis Retry-After abgelaufen ist.
IMPORT_RATE_LIMITED429Import per Link: 20 Importe in der letzten Stunde. Warte, bis Retry-After abgelaufen ist, oder lade die Dateien hoch.
IMPORT_UNAVAILABLE503Der Import per Link ist gerade nicht verfügbar. Lade die Datei stattdessen hoch.

Häufige HTTP-Statuscodes:

CodeBedeutung
400Ungültige Anfrage (z. B. weniger als zwei Videoquellen bei der Verarbeitung)
401Fehlender oder ungültiger API-Key
403Kontingent überschritten, oder der Upload gehört zu einem anderen Konto
404Job nicht gefunden oder nicht in deinem Besitz
409Ungültiger Statusübergang (z. B. Rendering eines Jobs, der noch nicht „ready” ist) oder eine Anfrage mit demselben Idempotency-Key, die noch läuft
422Ein Idempotency-Key, der mit einem anderen Request-Body wiederverwendet wurde
429Zu viele Importe per Link gleichzeitig oder in der letzten Stunde
500Serverfehler
502Ein Verarbeitungsdienst hat den Job abgelehnt oder konnte nicht starten
503Dienst nicht verfügbar

Vollständiger Ablauf

Der komplette Ablauf für einen KI-Agenten oder eine Automatisierung:

# 1. Job mit zwei Kameras anlegen (Dateien bis 5 GB, für größere
#    Dateien (bis 100 GB) fileSize angeben, dann läuft der Upload als Multipart)
JOB=$(curl -s -X POST https://wizcut.com/api/jobs \
  -H "Authorization: Bearer wc_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "sources": [
      {"label": "Camera 1", "kind": "video"},
      {"label": "Camera 2", "kind": "video"}
    ],
    "callbackUrl": "https://your-server.com/webhook"
  }')

JOB_ID=$(echo $JOB | jq -r '.jobId')

# 2. Videodateien an die presigned URLs hochladen
curl -X PUT -T camera1.mp4 "$(echo $JOB | jq -r '.uploads | to_entries[0].value.url')"
curl -X PUT -T camera2.mp4 "$(echo $JOB | jq -r '.uploads | to_entries[1].value.url')"

# 3. Verarbeitung starten
curl -s -X POST "https://wizcut.com/api/jobs/$JOB_ID/process" \
  -H "Authorization: Bearer wc_live_your_key"

# 4. Auf den nächsten Webhook warten. Mit dem Standardwert autoMap ("confident"):
#    - { status: "ready", reviewUrl: "..." }: WizCut hat die Kameras selbst zugeordnet
#    - { status: "mapping", reviewUrl: "...", speakers: [...], cameraMap: {...} }:
#      WizCut war sich nicht sicher. Einen Menschen zur reviewUrl schicken, um die Kameras
#      zu bestätigen (oder die Zuordnung selbst per POST an /api/jobs/$JOB_ID/tracks senden)

# 5. Mensch prüft und bearbeitet Schnitte → klickt im Editor auf Render
#    Auf Webhook warten: { status: "complete", outputUrl: "..." }

# 6. Fertig gerendertes Video von outputUrl herunterladen

Vollautomatisch (autoMap: "always", review: false):

# Wie oben, aber "autoMap": "always" und "review": false in Schritt 1 ergänzen
# WizCut ordnet die Kameras selbst zu, auch wenn es sich nicht sicher ist,
# und startet direkt danach das Rendering, ganz ohne menschliches Zutun
# Ergebnis: { status: "ready", ... }, danach { status: "complete", outputUrl: "..." }

Integrationen

Lieber ohne Code? Die WizCut API lässt sich auch über Automatisierungsplattformen steuern, ohne dass du die oben beschriebenen Anfragen selbst schreiben musst.

n8n

Wir pflegen eine offizielle n8n-Integration mit dem verifizierten Community-Node @wizcut/n8n-nodes-wizcut. Installieren lässt er sich in n8n unter Settings → Community Nodes. Da er verifiziert ist, steht er auch in n8n Cloud zur Verfügung.

Der Node kommt in zwei Varianten:

  • WizCut: Aktionen für Create Job, Get Job, Start Processing, Start Render und Approve.
  • WizCut Trigger: ein Webhook-Trigger, der deinen Workflow startet, sobald sich der Job-Status ändert (mapping, ready, complete, approved).

Die Nodes können noch nicht per Link importieren. Für Dateien, die schon in einem Cloud-Speicher liegen, fügst du sie mit einem HTTP-Request-Node hinzu, wie unter Dateien per Link importieren beschrieben.

Du verbindest die Webhook-URL des Triggers mit der callbackUrl deines Jobs und erhältst eine vollständig ereignisgesteuerte Pipeline. Zum Beispiel: Slack-Benachrichtigung, wenn jemand bestätigen soll, wer auf welcher Kamera zu sehen ist, automatischer Render-Start sobald die Schnitte bereit sind, und Download-Link, wenn die Episode fertig ist. Beide Nodes lassen sich außerdem als Tools für n8n-KI-Agenten einsetzen.

Für den schnellen Einstieg gibt es eine fertige Vorlage: Podcast-Schnittstatus mit WizCut und Slack automatisch verwalten.

Weitere Plattformen

Make.com- und Zapier-Integrationen sind in Planung. Du arbeitest mit einer anderen Plattform oder brauchst eine Workflow-Vorlage für deinen konkreten Anwendungsfall? WizCut-Support kontaktieren. Funktionswünsche sind willkommen.

WizCut API – WizCut Docs