Guía de Generación de Video con Kie.ai: Veo 3.1, Kling 3.0 y la API de Seedance

Las imágenes son la parte fácil del contenido generado por IA. El video es donde se complica: Veo necesita una clave de Google, Kling pide su propia cuenta, Seedance tiene su propia cuota, y todos generan de forma asíncrona — creas una tarea, esperas minutos, obtienes una URL que expira y cruzas los dedos para que el pipeline no se haya roto en el camino.

Kie.ai resuelve la parte de la integración: una API key, una billetera de créditos y más de 30 modelos de texto-a-video detrás del mismo flujo createTask — Veo 3.1, Kling 3.0, Seedance 2.0, Wan, Hailuo, Grok Imagine, PixVerse V6 y más. Ya uso Kie como backend de generación para portadas de blog y miniaturas de YouTube (Agrega un Agente de Imagen IA a Mastra con Kie.ai). Esta guía cubre el lado del video: qué modelos existen, cuánto cuestan por segundo, cómo funcionan los trabajos asíncronos y un script listo para copiar y pegar que genera un video y lo descarga al disco.

Por qué usar Kie.ai para video

El argumento es el mismo que para las imágenes: una sola superficie de integración en lugar de un SDK por proveedor. Con el video duele más, porque cada proveedor tiene un payload distinto, una historia de polling distinta y una unidad de facturación distinta (por video, por segundo, por nivel de resolución).

Así se ve el Market ahora mismo (verificado en agosto de 2026, compruébalo en vivo):

Reglas de la plataforma que importan para los presupuestos de video:

• 1 crédito = $0.005. Una tarea de video suele costar 100–500 créditos (rango según la documentación), por eso un solo clip va de centavos a un par de dólares.
• Las tareas fallidas no se cobran (según la plataforma) — cómodo cuando generas por lotes y reintentas.
• Los créditos nunca expiran; las cuentas nuevas reciben créditos de prueba gratis más un Playground para probar prompts antes de escribir código.
• Las URLs de video son temporales — tienes que descargar los resultados tú mismo.

Mantengo la comparación completa de precios y competidores en la Reseña de Kie.ai. Esta guía asume que ya decidiste que Kie vale la pena y quieres el flujo de trabajo de video.

Cómo funciona la generación de video en Kie

Todos los modelos de video del Market comparten un mismo patrón asíncrono:

1. POST https://api.kie.ai/api/v1/jobs/createTask
   Authorization: Bearer YOUR_API_KEY
   body: { model, input, callBackUrl? }

2. 200 + taskId   → task accepted, NOT finished

3a. Poll GET /api/v1/jobs/recordInfo?taskId=...
    until state = success | fail
    (states: waiting | queuing | generating | success | fail)
 OR
3b. Wait for your callBackUrl webhook

4. Parse resultUrls from resultJson
5. Download the MP4 yourself — URLs expire fast

Dos hechos prácticos con los que me topo constantemente:

• Las URLs de resultado caducan rápido. La mejor práctica de la documentación dice descargar de inmediato porque las URLs de contenido generado suelen expirar tras ~24 horas. Tu cuenta conserva los registros de tareas (~2 meses) y los medios (~14 días), pero trata la URL como de corta duración y lleva el archivo a tu propio almacenamiento en cuanto la tarea termine con éxito.
• Los límites de velocidad son reales. Unas 20 solicitudes nuevas por cada 10 segundos por defecto; las creaciones rechazadas no se encolan, así que aplica backoff ante un HTTP 429.

Texto-a-video: Kling 3.0 a través de la API del Market

Aquí tienes un ejemplo verificado de createTask usando el id de modelo de Kling 3.0 (kling-3.0/video), directamente de docs.kie.ai:

curl -X POST https://api.kie.ai/api/v1/jobs/createTask \
  -H "Authorization: Bearer $KIE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-3.0/video",
    "input": {
      "prompt": "A red fox trots through a snowy pine forest at dawn, low tracking camera, soft volumetric light, cinematic",
      "duration": "5",
      "aspect_ratio": "16:9",
      "mode": "std",
      "sound": true,
      "multi_shots": false
    }
  }'

Respuesta — un id de tarea, no un video:

{
  "code": 200,
  "msg": "success",
  "data": {
    "taskId": "task_kling-3.0_1765187774173"
  }
}

Haz polling hasta que termine:

curl "https://api.kie.ai/api/v1/jobs/recordInfo?taskId=task_kling-3.0_1765187774173" \
  -H "Authorization: Bearer $KIE_API_KEY"

En caso de éxito obtienes state: "success" y la URL de descarga dentro de resultJson:

{
  "code": 505,
  "msg": "success",
  "data": {
    "taskId": "task_kling-3.0_1765187774173",
    "model": "kling-3.0/video",
    "state": "success",
    "resultJson": "{\"resultUrls\":[\"https://example.com/generated-video.mp4\"]}",
    "progress": 100,
    "creditsConsumed": 35
  }
}

Descárgalo:

curl -L -o fox.mp4 "https://example.com/generated-video.mp4"

Opciones específicas de Kling 3.0 que conviene conocer:

• mode: std, pro o 4K. Las resoluciones se derivan de aspect_ratio (16:9 → 1280x720 en std, etc.). 4K cuesta más y tarda más.
• multi_shots: true cambia a un array multi_prompt, cada plano con su propio prompt y duración (1–12s, máx. 500 caracteres por plano, total hasta 15s).
• sound: true genera audio nativo (diálogo, efectos) — duplica aproximadamente el precio por segundo.
• Imágenes de primer/último fotograma vía image_urls; cuando proporcionas imágenes, aspect_ratio pasa a ser opcional (se adapta automáticamente).

Veo 3.1: el endpoint dedicado

Veo 3.1 no es un modelo createTask del Market — Kie le da su propio endpoint con herramientas extra de fiabilidad a aproximadamente el 25% del precio directo de Google:

curl -X POST https://api.kie.ai/api/v1/veo/generate \
  -H "Authorization: Bearer $KIE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Aerial drone shot over a misty mountain lake at sunrise, cinematic 1080p",
    "model": "veo3_fast",
    "aspect_ratio": "9:16",
    "generationType": "TEXT_2_VIDEO",
    "callBackUrl": "https://your-app.example/kie/callback"
  }'

Detalles de la documentación de Veo 3.1:

• Modelos: Veo 3.1 Quality (insignia), Veo 3.1 Fast (rentable), Veo 3.1 Lite (mayor volumen). Id de ejemplo en la documentación: veo3_fast.
• Modos de generación: TEXT_2_VIDEO, FIRST_AND_LAST_FRAMES_2_VIDEO (transición entre dos imágenes), REFERENCE_2_VIDEO (basado en material, solo Fast/Lite).
• 9:16 y 16:9 nativos a 1080p o 4K. El 4K pasa por un endpoint separado y cuesta ~2x un video Fast.
• Todos los videos incluyen una pista de audio de fondo por defecto.
• Campos opcionales watermark y enableTranslation.

La respuesta también devuelve un taskId (p. ej. veo_task_abcdef123456); haz polling en el mismo endpoint recordInfo o usa el callback para saber cuándo termina.

Imagen-a-video con referencias

La mayoría de los modelos de video aceptan una imagen inicial, y Kling 3.0 también admite fotogramas de inicio + fin. Primero sube tu imagen local al alojamiento de archivos de Kie y luego referencia la URL devuelta en la tarea.

Subida (patrón base64 que uso en el agente de imagen de Mastra):

curl -X POST https://kieai.redpandaai.co/api/file-base64-upload \
  -H "Authorization: Bearer $KIE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "base64Data": "data:image/png;base64,iVBORw0KGgo...",
    "uploadPath": "images",
    "fileName": "fox.png"
  }'

La respuesta contiene downloadUrl / fileUrl — úsala como image_urls[0] en una tarea de Kling:

{
  "model": "kling-3.0/video",
  "input": {
    "prompt": "The fox from the image turns its head and starts running through the snow",
    "image_urls": ["https://kieai.redpandaai.co/.../fox.png"],
    "duration": "5",
    "sound": true,
    "multi_shots": false
  }
}

Para Veo 3.1, la misma URL de subida va en imageUrls con generationType: "REFERENCE_2_VIDEO" (o FIRST_AND_LAST_FRAMES_2_VIDEO con dos imágenes). Los archivos subidos son temporales en el host de Kie — pásalos a una tarea de inmediato.

Webhooks en lugar de polling

Los trabajos de video largos son exactamente donde quieres callBackUrl. Añádelo a cualquier tarea y Kie notifica a tu endpoint cuando la tarea termina, así nada se queda en un bucle de espera activa. Las claves exactas del payload varían por modelo — trata el callback como un disparador y consulta siempre recordInfo después para obtener el estado canónico y las resultUrls.

Receptor mínimo en Node:

import { createServer } from "node:http";

createServer(async (req, res) => {
  let body = "";
  for await (const chunk of req) body += chunk;
  const payload = JSON.parse(body || "{}");
  console.log("Kie callback:", payload);
  // Then: fetch recordInfo?taskId=... to get resultUrls and download.
  res.writeHead(200);
  res.end("ok");
}).listen(8080, () => console.log("webhook on :8080"));

Un script que genera y descarga

Aquí tienes un script sin dependencias (Node 22+ o Bun) que crea una tarea de video del Market, hace polling con backoff y guarda el MP4 en ./videos/:

#!/usr/bin/env node
// generate-video.mjs — Kie.ai text-to-video (Market API) + download
import { mkdirSync, writeFileSync } from "node:fs";
import { join } from "node:path";

const KIE_API = "https://api.kie.ai";
const KEY = process.env.KIE_API_KEY;
if (!KEY) {
  console.error("Set KIE_API_KEY first (from https://kie.ai/api-key)");
  process.exit(1);
}

async function createTask(model, input, callBackUrl) {
  const res = await fetch(`${KIE_API}/api/v1/jobs/createTask`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ model, input, callBackUrl }),
  });
  const json = await res.json();
  if (json?.code !== 200) {
    throw new Error(json?.msg || `createTask failed (HTTP ${res.status})`);
  }
  return json.data.taskId;
}

async function waitForVideo(taskId, { timeoutMs = 15 * 60 * 1000, intervalMs = 5000 } = {}) {
  const start = Date.now();
  let delay = intervalMs;
  while (Date.now() - start < timeoutMs) {
    const res = await fetch(
      `${KIE_API}/api/v1/jobs/recordInfo?taskId=${encodeURIComponent(taskId)}`,
      { headers: { Authorization: `Bearer ${KEY}` } },
    );
    const json = await res.json();
    const data = json?.data;
    if (!data) throw new Error(json?.msg || "No task data");
    if (data.state === "success") {
      const parsed = JSON.parse(data.resultJson || "{}");
      const urls = parsed.resultUrls ?? [];
      if (!urls.length) throw new Error("Task succeeded but no resultUrls");
      return { urls, credits: data.creditsConsumed };
    }
    if (data.state === "fail") {
      throw new Error(data.failMsg || "Task failed");
    }
    console.log(`  ${data.state} (progress ${data.progress ?? "?"}%)...`);
    await new Promise((r) => setTimeout(r, delay));
    delay = Math.min(delay * 1.25, 15000);
  }
  throw new Error(`Timed out waiting for ${taskId}`);
}

async function main() {
  const model = process.env.KIE_MODEL || "kling-3.0/video";
  const prompt = process.argv[2] || "A red fox trots through a snowy pine forest at dawn, cinematic";
  const outDir = join(process.cwd(), "videos");
  mkdirSync(outDir, { recursive: true });

  console.log(`Creating video task (${model})...`);
  const taskId = await createTask(
    model,
    { prompt, duration: "5", aspect_ratio: "16:9", mode: "std", sound: true, multi_shots: false },
    process.env.KIE_CALLBACK_URL,
  );
  console.log(`taskId: ${taskId}`);

  const { urls, credits } = await waitForVideo(taskId);
  const safeName = taskId.replace(/[^a-zA-Z0-9._-]/g, "_");
  const outPath = join(outDir, `${safeName}.mp4`);

  console.log(`Downloading ${urls[0]}`);
  const res = await fetch(urls[0]);
  if (!res.ok) throw new Error(`Download failed HTTP ${res.status}`);
  writeFileSync(outPath, Buffer.from(await res.arrayBuffer()));

  console.log(`Saved ${outPath} (${credits ?? "?"} credits consumed)`);
}

main().catch((err) => {
  console.error(err.message);
  process.exit(1);
});

Ejecútalo:

export KIE_API_KEY=your-key
node generate-video.mjs "A slow pan over a neon city street at night, rain reflections, 9:16"
# KIE_MODEL=kling-3.0/video KIE_CALLBACK_URL=https://your-app.example/kie node generate-video.mjs "..."

El script cubre las tres cosas que más muerden: creación de la tarea, polling con backoff exponencial y guardar el archivo antes de que la URL expire. Si prefieres una versión tipada, el artículo del agente de imagen de Mastra muestra el mismo patrón como herramientas de TypeScript (createTask → pollTaskUntilDone → downloadToGenerated).

Qué modelo elegir

La estructura del prompt importa más que el modelo: sujeto, acción, escena, movimiento de cámara, iluminación y proporción. Prueba en el Playground gratuito antes de gastar créditos en un bucle.

Control de costos

Calcula el presupuesto por clip antes de automatizar:

Consulta kie.ai/pricing para cifras en vivo. Mis reglas: prueba los prompts en el Playground, fija un presupuesto de créditos en la billetera, descarga de inmediato y vigila los registros de tareas para ver creditsConsumed tras las primeras ejecuciones. A $0.10–$0.40 por Short, un lote de 10 sigue costando menos que un café — pero un trabajo de 15s en 4K con audio puede pasar de un par de dólares, así que no hagas bucles a ciegas.

Agente de video en Mastra

El patrón del agente de imagen se traslada directamente: un LLM elige un modelo, llama a una herramienta generate_kie_video que envuelve createTask + poll + descarga, una herramienta get_kie_video_task para el estado y get_kie_credits antes de las ejecuciones por lotes. Así es como planeo conectar el video al asistente Mastra para los clips de @webdoze — mismas herramientas, distinto esquema de entrada por modelo.

Ventajas y desventajas

Ventajas

• Una clave y una billetera para más de 30 modelos de video; cambia de modelo sin nuevos SDKs
• Precios agresivos frente a fal.ai / Replicate en Veo (hasta ~60–70% del listado)
• Las tareas fallidas no se cobran (según la plataforma) — seguro para bucles de reintento
• Los créditos nunca expiran; créditos de prueba gratis + Playground
• Forma asíncrona consistente entre los modelos del Market; webhooks callBackUrl soportados
• La retención de medios y los registros te dejan un rastro

Desventajas

• Las URLs de resultado expiran rápido (~24h según la documentación) — tu pipeline debe descargar de inmediato
• Los trabajos tardan minutos; no es una API síncrona
• Los ids de modelo y los campos de entrada difieren por modelo — lee la documentación de cada modelo
• Riesgo de intermediario: las caídas del proveedor original también te afectan
• Los límites de velocidad (~20 solicitudes nuevas/10s) muerden la automatización masiva sin backoff
• El precio por segundo suma rápido en clips largos; el 4K y el audio multiplican el costo

Preguntas frecuentes

Conclusión

Kie.ai hace que la generación de video sea práctica para automatizar: una API para Veo 3.1, Kling 3.0, Seedance 2.0, Wan y el resto, trabajos asíncronos con webhooks y precios por debajo de los endpoints oficiales. Las desventajas son las que puedes resolver con código — URLs que expiran, trabajos de minutos y diferencias de entrada por modelo.

Empieza con los créditos gratuitos, genera un clip en el Playground y luego ejecuta el script de arriba para asegurarte de que tu paso de descarga funciona antes de construir el pipeline.