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.

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:

Feld	Typ	Beschreibung
`sources`	array	Kamerawinkel 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` in Bytes.
`callbackUrl`	string	Optional. URL, an die Webhook-Benachrichtigungen gesendet werden, siehe Webhooks.
`review`	boolean	Standard: `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.
`autoMap`	string	Standard: `"confident"`. Legt fest, ob WizCut selbst entscheiden darf, wer auf welcher Kamera zu sehen ist: `"off"`, `"confident"` oder `"always"`, siehe Automatische Kamerazuordnung.
`silence`	object	Optional. Automatisches Entfernen von Pausen, siehe Pausen entfernen. Ohne Angabe ist die Funktion deaktiviert.

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.

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.

Dateien hochladen

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

"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:

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.

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.

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. 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.

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, created_at und updated_at.

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://..."
}

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.

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:

Status	Bedeutung
`created`	Job angelegt, wartet auf Uploads
`uploading`	Wartet, bis alle Dateien hochgeladen sind (z. B. nachdem ein fehlgeschlagener Job neu gestartet wurde)
`syncing`	Audio-Synchronisation zwischen den Quellen
`diarizing`	Sprechererkennung läuft
`mapping`	Sprecher erkannt. WizCut ermittelt noch, wer auf welcher Kamera zu sehen ist, oder ein Mensch (bzw. dein Agent) muss die Zuordnung bestätigen
`ready`	Schnitte generiert, bereit zur Prüfung oder zum Rendering
`rendering`	Finales Rendering läuft
`complete`	Rendering abgeschlossen, `output_url` verfügbar
`approved`	Ausgabe von einem Menschen bestätigt
`failed`	Fehler aufgetreten, Details in `error_message`

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.

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.

Webhooks sind noch nicht signiert. Behandle einen eingehenden Webhook deshalb als Signal, den Job per GET /api/jobs/{jobId} abzurufen, statt seinem Inhalt zu vertrauen. 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..."
}

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

{
  "jobId": "uuid",
  "status": "approved",
  "outputUrl": "https://presigned-download-url..."
}

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.

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.

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:

Prüfen, welcher Sprecher auf welcher Kamera zu sehen ist (Kameras, bei denen sich WizCut sicher ist, sind bereits ausgewählt)
Die automatisch generierten Schnitte in der Vorschau prüfen und bearbeiten
Auf „Render” klicken, wenn alles stimmt (bei review: true, dem Standard)
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:

Modus	Was WizCut tut	Sinnvoll, 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:

Feld	Beschreibung
`sourceId`	Eine der Videoquellen des Jobs.
`kind`	Was 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`.
`confidence`	`high` (WizCut ist sicher), `low` (eine wahrscheinliche, aber nicht sichere Antwort) oder `none` (keine Antwort).
`speakers`	Wer auf der Kamera zu sehen ist. Leer, wenn `confidence` den Wert `none` hat. Bei Zweiereinstellungen und Totalen von links nach rechts.
`positions`	Nur bei Zweiereinstellungen und Totalen: wer links (`left`), in der Mitte (`middle`) und rechts (`right`) im Bild sitzt.
`reason`	Hat den Wert `no_motion`, wenn eine Kamera gar nicht analysiert werden konnte.
`z`, `lagErrorS`	Diagnosewerte 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:

Feld	Beschreibung
`speakers`	Die Sprecher, die WizCut bewertet hat: alle mit mindestens einer Minute Sprechzeit.
`unassignedSpeakers`	Bewertete Sprecher, die auf keiner `high`-Kamera zu sehen sind. Ist die Liste nicht leer, überlässt „confident” die Entscheidung einem Menschen.
`droppedSpeakers`	Sprecher 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. 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:

Modus	Verhalten
`off`	Alle Pausen bleiben wie aufgenommen erhalten (Standard, wenn `silence` weggelassen wird).
`tighten`	Lange Pausen werden auf einen natürlichen Beat gekürzt (~0,7 s). Empfohlen: Das Gespräch bleibt menschlich.
`remove`	Lange 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):

Feld	Standard	Bereich	Beschreibung
`minPauseSec`	`1.5`	0.3–10	Nur Pausen, die länger sind, werden bearbeitet.
`keepPauseSec`	`0.7`	0–3	Der Beat, der anstelle einer gestrafften Pause stehen bleibt (nur im Modus `tighten`).
`paddingSec`	`0.25`	0–1	Sicherheitsabstand, 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.

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.

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.

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”.

Fehlerantworten

Alle Endpunkte liefern Fehler in diesem Format:

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

Manche Fehler enthalten zusätzlich einen maschinenlesbaren code:

Code	HTTP	Bedeutung
`TRACKS_ON_CREATE`	400	`POST /api/jobs` hat eine Sprecher-Zuordnung erhalten. Lass `tracks` weg und nutze `autoMap`, oder setze die Zuordnung später.
`UNKNOWN_SOURCE`	400	Ein Track nennt eine `sourceId`, die keine Videoquelle des Jobs ist.
`CUTS_REQUIRED`	400	Wer die Zuordnung ändert, nachdem Schnitte existieren, muss auch die aktualisierten `cuts` mitsenden.
`NOT_ENOUGH_VIDEOS`	400	Für die Verarbeitung braucht der Job mindestens zwei Videoquellen.
`QUOTA_EXCEEDED`	403	Deine Minuten sind aufgebraucht.
`INVALID_STATUS`	409	Der Job befindet sich nicht in einem Status, der das erlaubt, zum Beispiel weil seine Zuordnung schon abgeschickt wurde.
`NO_CUTS`	409	Es gibt keine Schnitte zum Rendern.

Häufige HTTP-Statuscodes:

Code	Bedeutung
400	Ungültige Anfrage (z. B. weniger als zwei Videoquellen bei der Verarbeitung)
401	Fehlender oder ungültiger API-Key
403	Kontingent überschritten
404	Job nicht gefunden oder nicht in deinem Besitz
409	Ungültiger Statusübergang (z. B. Rendering eines Jobs, der noch nicht „ready” ist)
500	Serverfehler
502	Ein Verarbeitungsdienst hat den Job abgelehnt oder konnte nicht starten
503	Dienst 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 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).

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.