API de WizCut

La API de WizCut te permite automatizar la edición de podcasts multicam. Subís los ángulos de cámara, WizCut detecta los hablantes, averigua quién está en cuál cámara y genera los cortes, opcionalmente los revisás en un editor online, y recibís el video renderizado por webhook.

Autenticación

Creá una API key en wizcut.com/settings. Incluila en cada request:

Authorization: Bearer wc_live_your_key_here

Las keys se pueden revocar en cualquier momento desde la página de configuración.

Crear un job

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

Campos:

Campo	Tipo	Descripción
`sources`	array	Ángulos de cámara o archivos de audio, hasta 12 por job. Un job necesita al menos dos fuentes de video para poder procesarse. Cada uno tiene `label`, `kind` opcional (`"video"` o `"audio"`, por defecto `"video"`), `ext` opcional (`mp4`, `mov`, `webm`, `mkv`, `wav`, `mp3`, `m4a` o `aac`; por defecto `"mp4"` para video, `"wav"` para audio) y `fileSize` opcional en bytes.
`callbackUrl`	string	Opcional. URL que recibe las notificaciones webhook, ver Webhooks.
`review`	boolean	Por defecto `true`. Con `true`, el job se pausa en “ready” para que un humano revise los cortes antes del render. Con `false`, el render arranca automáticamente apenas se envía el mapeo de hablantes, ya sea una persona, tu código o el propio WizCut.
`autoMap`	string	Por defecto `"confident"`. Si WizCut puede decidir por su cuenta quién está en cuál cámara: `"off"`, `"confident"` o `"always"`, ver Mapeo automático de cámaras.
`silence`	object	Opcional. Eliminación automática de pausas, ver Eliminación de silencios. Si se omite, está desactivado.

No se puede pasar el mapeo de hablantes (tracks) acá: los IDs de fuente recién existen cuando el job está creado, así que todavía no hay a qué cámara apuntar un hablante. Una lista tracks que nombre hablantes se rechaza con 400 y "code": "TRACKS_ON_CREATE". Usá autoMap, o mapeá los hablantes por la API cuando termine la detección de hablantes.

Pasá fileSize para todo archivo del que sepas el tamaño. Los archivos de más de 100 MB usan entonces una subida multipart: podés subir las partes en paralelo, reintentar una sola parte, y es la única forma de subir archivos de más de 5 GB. Sin fileSize, todos los archivos se suben con un único PUT prefirmado.

Respuesta:

{
  "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 está indexado por los IDs de fuente que asigna WizCut, en el mismo orden que tu array sources. Podés ignorar audioUploads: lo usan las apps de WizCut, que suben una pista de audio extraída antes que el video.

Subir archivos

Las URLs prefirmadas no necesitan header de autenticación: ya traen la autenticación incorporada.

"method": "put": hacé PUT del archivo completo a url dentro de la próxima hora:

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

"method": "multipart": partí el archivo en fragmentos de partSize bytes (el último puede ser más corto) y hacé PUT del fragmento n a la URL de la parte n:

urls trae las URLs de las primeras partes (urls[0] es la parte 1). Pedí más a medida que avanzás, hasta 16 por request:
```
POST /api/jobs/{jobId}/sources/{sourceId}/parts
```
```
{ "uploadId": "...", "partNumbers": [5, 6, 7, 8] }
```
La respuesta mapea números de parte a URLs: { "urls": { "5": "https://...", "6": "https://..." } }. Las URLs de cada parte son válidas por dos horas, así que pedilas poco antes de usarlas.

Una vez subidas todas las partes, cerrá la subida:

POST /api/uploads/complete

{ "key": "sources/uuid/source-uuid-1.mp4", "uploadId": "..." }

Para abandonar una subida, mandá el mismo body a POST /api/uploads/abort.

Iniciar el procesamiento

POST /api/jobs/{jobId}/process

Llamá a esto una vez que subiste todos los archivos. Arranca el pipeline: sincronización de audio, detección de hablantes, render de proxy, mapeo de cámaras y generación de cortes. El request devuelve inmediatamente y el procesamiento ocurre de forma asincrónica.

Body opcional:

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

diarizeSourceIds elige qué fuentes escucha WizCut para la detección de hablantes. Si lo omitís, WizCut usa tus fuentes de audio, o la primera fuente si no hay ninguna. Elegí las fuentes con el audio más limpio de todos los que hablan: una cámara con el micrófono silenciado o lejos puede dejarte con un job sin cortes.

Respuesta:

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

Listar jobs

GET /api/jobs

Devuelve { "jobs": [...] } con tus 50 jobs más recientes, del más nuevo al más viejo. Cada uno trae id, title, status, created_at y updated_at.

Ver el estado del job

GET /api/jobs/{jobId}

Respuesta:

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

El job en sí queda anidado bajo job. Las URLs firmadas de la respuesta (output_url, sourceUrls, audioUrl) se firman de nuevo en cada request, así que volvé a pedir el job en vez de guardarlas.

camera_map es la propuesta de WizCut sobre quién está en cuál cámara, ver El mapa de cámaras. Es null hasta que se calcula.

Valores de estado:

Estado	Significado
`created`	Job creado, esperando las subidas
`uploading`	Esperando que terminen de subirse los archivos (por ejemplo, después de reabrir un job fallido)
`syncing`	Alineando audio entre las fuentes
`diarizing`	Detectando hablantes
`mapping`	Hablantes detectados. WizCut todavía está averiguando quién está en cuál cámara, o una persona (o tu agente) tiene que confirmarlo
`ready`	Cortes generados, listo para revisión o render
`rendering`	Render final en progreso
`complete`	Render terminado, `output_url` disponible
`approved`	Un humano aprobó el resultado
`failed`	Algo salió mal, revisá `error_message`

Eliminar un job

DELETE /api/jobs/{jobId}

Elimina el job y todos sus archivos: uploads, proxies, el audio de detección de hablantes y el render. Funciona en cualquier estado; si una etapa todavía está corriendo, lo que genere se limpia cuando termina. Los minutos ya usados no se devuelven. Devuelve { "ok": true }, o 404 si el job no existe o no es tuyo.

Webhooks

Cuando proporcionás una callbackUrl, WizCut manda un POST con JSON cada vez que un job llega a uno de los estados de abajo. WizCut intenta cada entrega hasta tres veces y espera hasta 10 segundos a que tu endpoint responda.

Los webhooks todavía no están firmados, así que tratalos como una señal para pedir el job con GET /api/jobs/{jobId} en vez de confiar en su contenido. Sondeá también como respaldo, por si se pierde alguna entrega.

Webhook “mapping” (una persona tiene que confirmar quién está en cuál cámara):

{
  "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"], "...": "..." }
    ]
  }
}

Mandá a alguien a la reviewUrl para mapear los hablantes a las fuentes de cámara y revisar los cortes, o mapealos por la API. Los links de revisión son válidos por 72 horas. speakers lista los hablantes detectados, empezando por el que más habla.

cameraMap es la propuesta de WizCut, con la misma forma que camera_map en el job, ver El mapa de cámaras. Se omite cuando todavía no hay propuesta.

Cuándo llega este webhook depende de autoMap:

"confident" o "always": el job espera en “mapping” sin mandar webhook mientras WizCut averigua las cámaras, lo que tarda unos minutos una vez que los proxies están listos. Después, o mapea las cámaras por su cuenta y el próximo webhook que recibís es “ready”, o manda “mapping” con la propuesta adjunta. Si WizCut no puede calcular una propuesta (por ejemplo, porque falló un proxy), “mapping” se manda sin cameraMap, como máximo unos 30 minutos después de la detección de hablantes.
"off": “mapping” se manda enseguida después de la detección de hablantes, normalmente sin cameraMap. La propuesta aparece en GET /api/jobs/{jobId} unos minutos más tarde.

Webhook “ready” (mapeo de hablantes enviado, ya sea por una persona, tu código o WizCut, y cortes generados):

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

Webhook “complete” (render terminado):

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

Webhook “approved” (humano aprobó desde la UI de revisión):

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

Webhook “failed” (el job falló, en cualquier etapa):

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

error trae el mismo mensaje que GET /api/jobs/{jobId} devuelve como error_message, y failedAtStatus indica en qué etapa falló, por ejemplo syncing, diarizing o rendering. En la mayoría de las fallas de sincronización, detección de hablantes y render, WizCut hace primero un reintento por su cuenta: si te llega este webhook, es que el reintento tampoco funcionó.

El outputUrl de los webhooks “complete” y “approved” es válido por siete días después de terminar el render. GET /api/jobs/{jobId} siempre devuelve un output_url recién firmado.

Mapeo de hablantes y revisión (human-in-the-loop)

Después de la detección de hablantes, el job pasa al estado “mapping”. Los hablantes detectados tienen que mapearse a las fuentes de cámara: la detección identifica cuándo habla alguien, pero no en qué cámara está.

WizCut intenta resolver eso por vos. La gente se mueve cuando habla: gesticula, asiente, se inclina. Por eso WizCut compara cuándo habla cada hablante con el movimiento de cada cámara y propone quién está en cuál. Cuánto decide por su cuenta depende de vos, con autoMap.

Cuando hace falta una persona, WizCut manda el webhook “mapping”. Incluye una reviewUrl, un link firmado al editor de WizCut. Mandá a alguien ahí. En el editor, la persona:

Revisa qué hablante está en cuál cámara (las cámaras de las que WizCut está seguro ya vienen seleccionadas)
Previsualiza y edita los cortes generados automáticamente
Hace clic en “Render” cuando está listo (si review: true, que es el valor por defecto)
Opcionalmente hace clic en “Approve” después de revisar el resultado renderizado

Con review: false, el render arranca automáticamente en cuanto se envía el mapeo de hablantes. La persona no tiene la opción de revisar los cortes antes del render.

Mapeo automático de cámaras

Configurá autoMap cuando crees el job:

Modo	Qué hace WizCut	Elegilo cuando
`"off"`	Nunca mapea las cámaras por su cuenta. Manda “mapping” enseguida después de la detección de hablantes; la propuesta aparece en el job unos minutos más tarde para que la use una persona o tu agente.	De todas formas una persona siempre revisa el mapeo.
`"confident"`	Es el valor por defecto. Mapea las cámaras él mismo cuando está seguro de haber encontrado un primer plano de cada hablante, y pasa a “ready”. Si no, manda “mapping” con la propuesta adjunta. Un plano general o un two-shot se usa en la edición, pero nunca cuenta como la cámara propia de un hablante.	La mayoría de las integraciones. Solo sabés de WizCut cuando necesita ayuda.
`"always"`	No espera a una persona. Usa las respuestas de las que está seguro, después las probables, y ubica a quien quede en las cámaras restantes según el tiempo de habla. Solo manda “mapping” si no puede calcular ninguna propuesta (por ejemplo, porque falló un proxy).	Pipelines totalmente desatendidos que prefieren una edición a ojo antes que un job frenado.

“Seguro de cada hablante” significa: todos los que hablan al menos un minuto están en una cámara que WizCut respondió con confianza high. A las cámaras de las que no está seguro no les asigna hablantes, así que la edición no corta a ellas; si querés usarlas, corregilo en el editor.

Tené en cuenta que “confident” va a pedirle ayuda a una persona bastante seguido. Se frena con material donde el movimiento no sigue a un solo hablante: estudios de TV con señales conmutadas, eventos, cámaras en mano u operadas. Además necesita unos 20 minutos de conversación para estar seguro, así que los clips cortos suelen terminar en “mapping”. En nuestras pruebas hasta ahora, WizCut no puso a ningún hablante en la cámara equivocada cuando dijo estar seguro, pero la muestra todavía es chica.

Combinados con review: false, "confident" y "always" hacen que un job pueda renderizarse sin que nadie lo mire. Ese es el objetivo en pipelines desatendidos; si querés que una persona vea cada edición, mantené review: true.

El mapa de cámaras

La propuesta está en el job como camera_map (y en el webhook “mapping” como cameraMap). Es null hasta que se calcula, unos minutos después de que los proxies están listos. Este es el de un show de dos personas con un primer plano de cada una y un two-shot:

{
  "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 }
    }
  ]
}

Por cámara:

Campo	Descripción
`sourceId`	Una de las fuentes de video del job.
`kind`	Qué muestra la cámara: `closeup` (una persona), `twoshot` (dos personas una al lado de la otra), `wide` (tres personas), `multi` (varias personas, una después de otra, por lo general una cámara operada o conmutada) o `unknown`.
`confidence`	`high` (WizCut está seguro), `low` (una respuesta probable, no segura) o `none` (sin respuesta).
`speakers`	A quién muestra la cámara. Vacío cuando `confidence` es `none`. En two-shots y planos generales, de izquierda a derecha.
`positions`	Solo para two-shots y planos generales: quién está a la `left`, al `middle` y a la `right` del encuadre.
`reason`	Vale `no_motion` cuando no se pudo analizar la cámara en absoluto.
`z`, `lagErrorS`	Números de diagnóstico por hablante: qué tan de cerca el movimiento de la cámara sigue el habla de esa persona, y a cuántos segundos quedó el mejor calce. Sirven para depurar, pero no te apoyes en ellos.

Nivel superior:

Campo	Descripción
`speakers`	Los hablantes que WizCut evaluó: todos los que tienen al menos un minuto de habla.
`unassignedSpeakers`	Hablantes evaluados que no están en ninguna cámara `high`. Si no está vacío, “confident” deja la decisión a una persona.
`droppedSpeakers`	Hablantes con muy poca habla para evaluar, normalmente una etiqueta suelta o una interjección corta. WizCut no los ubica en ninguna cámara.

Para aceptar la propuesta tal cual, convertí cada cámara en la que confiás en un track (su sourceId y sus speakers) y enviala.

Mapear hablantes por la API

Si ya sabés quién está sentado frente a cada cámara, o tu agente revisó la propuesta, mandá vos mismo el mapeo mientras el job está en estado “mapping”:

POST /api/jobs/{jobId}/tracks

{
  "tracks": [
    { "sourceId": "source-uuid-1", "speakers": ["SPEAKER_00"] },
    { "sourceId": "source-uuid-2", "speakers": ["SPEAKER_01"] }
  ]
}

Usá los nombres de hablante del webhook “mapping” (o los turns de GET /api/jobs/{jobId}) y los IDs de tus fuentes de video. Una cámara puede mostrar a más de un hablante. WizCut genera entonces los cortes, pasa el job a “ready”, manda el webhook “ready” y, con review: false, arranca el render. La respuesta trae los nuevos cuts.

Cada sourceId tiene que ser una de las fuentes de video del job; cualquier otro recibe un 400 con "code": "UNKNOWN_SOURCE". Podés enviar el mapeo mientras WizCut todavía está averiguando las cámaras: gana el que llegue primero. Si el mapeo ya se envió, por ejemplo de forma automática, recibís un 409 con "code": "INVALID_STATUS".

Avanzado: corregir un mapeo cuando ya existen cortes. Una vez que el job está “ready” o “complete”, el mismo endpoint todavía puede cambiar el mapeo, pero ya no genera los cortes por vos: mandá los cuts corregidos junto con tracks (y opcionalmente removedRanges), o recibís un 400 con "code": "CUTS_REQUIRED". WizCut guarda las dos cosas juntas, así que un recut posterior usa el mapeo corregido. No manda webhook ni arranca un render: disparalo si necesitás una salida nueva. El editor de WizCut hace todo esto por vos cuando alguien corrige un mapeo ahí.

Eliminación de silencios

WizCut puede acortar o eliminar automáticamente las pausas largas antes de generar los cortes. Esto pasa primero, así que el cambio de cámara se decide sobre la conversación ya ajustada: nunca vas a terminar con un corte a una cámara que pierde de inmediato la mayor parte de su tiempo en pantalla por una pausa eliminada.

Activalo con el campo silence al crear un job:

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

Modos:

Modo	Comportamiento
`off`	Mantiene todas las pausas tal como se grabaron (valor por defecto cuando se omite `silence`).
`tighten`	Acorta las pausas largas a un compás natural (~0.7s). Recomendado: mantiene la conversación sonando humana.
`remove`	Corta las pausas largas casi por completo, dejando apenas el padding necesario para no cortar palabras.

Ajustes finos opcionales (los valores por defecto funcionan bien para la mayoría de las grabaciones):

Campo	Por defecto	Rango	Descripción
`minPauseSec`	`1.5`	0.3–10	Solo se tocan las pausas más largas que este valor.
`keepPauseSec`	`0.7`	0–3	El compás que queda en lugar de una pausa ajustada (solo en el modo `tighten`).
`paddingSec`	`0.25`	0–1	Margen de seguridad que se mantiene alrededor del habla en cada rango eliminado.

La detección es conservadora: una pausa solo se elimina cuando la detección de hablantes y un análisis de energía del audio coinciden en que es silencio, así que las risas y otros momentos que no son habla se conservan.

El objeto del job (GET /api/jobs/{jobId}) incluye removed_ranges, los tramos eliminados en tiempo de la fuente como { startMs, endMs }, junto con cuts. El render final se salta estos rangos; el editor de revisión los muestra como secciones rayadas que se pueden restaurar.

Cambialo después del procesamiento con el endpoint de recut:

POST /api/jobs/{jobId}/recut

{ "silence": { "mode": "remove", "minPauseSec": 1.0 } }

Recut regenera los cortes y los rangos eliminados a partir de los hablantes ya detectados, sin reprocesar, así que devuelve la respuesta de inmediato con los nuevos cuts, removedRanges y savedMs (cuánto más corto queda el resultado). Pasá { "mode": "off" } para desactivar la eliminación de silencios de nuevo; omití silence por completo para mantener la configuración guardada del job.

Nota sobre facturación: el uso se mide en minutos de entrada (el material que subís), así que la eliminación de silencios no cambia lo que cuesta un job, solo hace que el resultado quede más ajustado.

Avanzado: control programático de cortes

Para pipelines completamente automatizados que saltean la UI por completo, dejá que WizCut mapee las cámaras o mapeá los hablantes por la API, y después gestionás vos mismo los cortes y el render. Estos endpoints funcionan mientras el job está “ready” o “complete”:

Actualizar cortes:

PATCH /api/jobs/{jobId}/cuts

{
  "cuts": [
    { "startMs": 0, "endMs": 5000, "sourceId": "source-uuid-1" },
    { "startMs": 5000, "endMs": 12000, "sourceId": "source-uuid-2" }
  ]
}

El mismo endpoint también acepta removedRanges (un array de { startMs, endMs }) para editar directamente los tramos de eliminación de silencios, por ejemplo para restaurar una pausa que la pasada automática eliminó. Podés mandar cuts, removedRanges, o los dos.

Disparar el render:

POST /api/jobs/{jobId}/render

Funciona desde “ready”, o desde “complete” para volver a renderizar después de editar los cortes. Devuelve { "jobId": "uuid", "status": "rendering" }, o un 409 con "code": "NO_CUTS" si el job no tiene cortes para renderizar.

Aprobar el resultado:

POST /api/jobs/{jobId}/approve

Solo funciona una vez que el job está “complete”. Lo pasa a “approved” y manda el webhook “approved”.

Respuestas de error

Todos los endpoints devuelven errores en este formato:

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

Algunos errores también traen un code legible por máquina:

Code	HTTP	Significado
`TRACKS_ON_CREATE`	400	`POST /api/jobs` recibió un mapeo de hablantes. Dejá afuera `tracks` y usá `autoMap`, o definí el mapeo más tarde.
`UNKNOWN_SOURCE`	400	Un track nombra un `sourceId` que no es una de las fuentes de video del job.
`CUTS_REQUIRED`	400	Cambiar el mapeo cuando ya existen cortes requiere también los `cuts` actualizados.
`NOT_ENOUGH_VIDEOS`	400	El job necesita al menos dos fuentes de video para procesarse.
`QUOTA_EXCEEDED`	403	Usaste todos tus minutos.
`INVALID_STATUS`	409	El job no está en un estado que permita esto, por ejemplo, su mapeo ya se envió.
`NO_CUTS`	409	No hay cortes para renderizar.

Códigos de estado HTTP más comunes:

Código	Significado
400	Request inválido (ej. menos de dos fuentes de video al procesar)
401	API key faltante o inválida
403	Cuota superada
404	Job no encontrado o no te pertenece
409	Transición de estado inválida (ej. renderizar un job que no está listo)
500	Error del servidor
502	Un servicio de procesamiento rechazó el job o no pudo arrancar
503	Servicio no disponible

Flujo completo

Acá está el camino feliz completo para un agente de IA o una automatización:

# 1. Crear un job con dos cámaras (archivos de hasta 5 GB cada uno,
#    pasá fileSize para subidas multipart en archivos más grandes)
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. Subir los videos a las URLs prefirmadas
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. Iniciar el procesamiento
curl -s -X POST "https://wizcut.com/api/jobs/$JOB_ID/process" \
  -H "Authorization: Bearer wc_live_your_key"

# 4. Esperar el próximo webhook. Con el autoMap por defecto ("confident"):
#    - { status: "ready", reviewUrl: "..." } → WizCut mapeó las cámaras solo
#    - { status: "mapping", reviewUrl: "...", speakers: [...], cameraMap: {...} }
#      → no estaba seguro. Mandar a una persona a la reviewUrl para confirmar las cámaras
#      (o mandar el mapeo vos mismo a /api/jobs/$JOB_ID/tracks)

# 5. La persona revisa y edita los cortes → hace clic en Render en el editor
#    Esperar el webhook: { status: "complete", outputUrl: "..." }

# 6. Descargar el video renderizado desde outputUrl

Totalmente desatendido (autoMap: "always", review: false):

# Igual que arriba, pero agregando "autoMap": "always" y "review": false en el paso 1
# WizCut mapea las cámaras solo, incluso cuando no está seguro,
# y arranca el render enseguida, sin ninguna persona de por medio
# Recibís: { status: "ready", ... } y después { status: "complete", outputUrl: "..." }

Integraciones

¿Preferís no escribir código? Podés manejar la API de WizCut desde plataformas de automatización sin necesidad de armar los requests a mano.

n8n

Mantenemos una integración oficial con n8n: el nodo de comunidad verificado @wizcut/n8n-nodes-wizcut. Instalalo desde Settings → Community Nodes en n8n (al estar verificado, también está disponible en n8n Cloud).

Incluye dos nodos:

WizCut: acciones para Create Job, Get Job, Start Processing, Start Render y Approve.
WizCut Trigger: un webhook trigger que arranca tu workflow cada vez que un job cambia de estado (mapping, ready, complete, approved).

Apuntá la URL del trigger a la callbackUrl de tu job y tenés un pipeline completamente event-driven. Por ejemplo, podés avisar por Slack cuando WizCut necesita que alguien confirme quién está en cuál cámara, arrancar el render automáticamente cuando los cortes están listos, y publicar el link de descarga cuando el episodio está terminado. Los dos nodos también funcionan como tools para agentes de IA de n8n.

¿Querés arrancar con algo ya armado? Usá el template disponible: Notify and manage podcast edit status with WizCut and Slack.

Más plataformas

Las integraciones con Make.com y Zapier están en el roadmap. Si estás trabajando en otra plataforma o necesitás un template de workflow para tu setup específico, contactá a soporte de WizCut. Los pedidos de nuevas funciones son bienvenidos.