---
title: "Guía de Generación de Video con Kie.ai: Veo 3.1, Kling 3.0 y la API de Seedance"
description: "Genera videos con IA usando Kie.ai: Veo 3.1, Kling 3.0, Seedance 2.0, Wan y más detrás de una sola API."
date: 2026-08-03
categories: ["ai"]
tags: ["kie-ai","video-generation","ai-tools"]
---
import Button from "@components/widgets/Button.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";
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](https://go.bitdoze.com/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](/es/agente-imagen-mastra-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.
Qué modelos de video expone Kie.ai y en qué destaca cada uno
Ejemplos de precios verificados (por video y por segundo)
El flujo asíncrono: crear tarea → polling o webhook → descargar
El endpoint dedicado de Veo 3.1 frente a la API `createTask` del Market
Imagen-a-video con imágenes de referencia subidas
Un script de Node funcional que genera y descarga un MP4
Control de costos y cuándo conviene saltarse Kie para video
Algunos enlaces de Kie.ai en este artículo son enlaces de afiliado (`https://go.bitdoze.com/kie-ai`). Uso el producto para la generación de medios en mi propio stack. La disponibilidad de modelos, los ids y los precios cambian rápido — verifica siempre contra la [página de precios de Kie](https://kie.ai/pricing) y la [documentación](https://docs.kie.ai/) antes de construir sobre una cifra concreta.
## 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):
| Modelo | Proveedor | Para qué es bueno | Precio de ejemplo en Kie |
|---|---|---|---|
| Veo 3.1 Quality / Fast / Lite | Google | 1080p cinematográfico, audio nativo, 9:16 nativo | Quality 1080p ~$1.28/video |
| Veo 3 Fast | Google | Clips rápidos y baratos con audio | ~$0.30–$0.40 por 8s |
| Veo 3 Quality | Google | Salida cinematográfica premium | ~$2.00 por 8s |
| Kling 3.0 (std / pro / 4K) | Kuaishou | Narrativa multi-plano, 3–15s, referencias de elementos | $0.07/s (std, sin audio) |
| Kling 3.0 Turbo | Kuaishou | Kling 3.0 más rápido y barato | Precio del Market |
| Kling 2.6 | Kuaishou | Audio nativo + voz | $0.28 por 5s HD |
| Seedance 2.0 | ByteDance | Generación realista rápida (~5 min/trabajo) | ~$0.057/s |
| Seedance 2.0 Mini | ByteDance | Generación económica por lotes | Precio del Market |
| Wan 2.6 / 2.7 | Alibaba | Multi-plano 1080p, T2V/I2V/R2V | Precio del Market |
| Hailuo 2.3 | MiniMax | Personajes expresivos, movimiento complejo | $0.15 por 6s |
| MiniMax H3 (Hailuo-03) | MiniMax | Video 2K, sonido estéreo nativo | Precio del Market |
| Grok Imagine | xAI | Movimiento realista + audio nativo | $0.10 por 6s |
| PixVerse V6, HappyHorse, Gemini Omni, Sora2, Runway Aleph | varios | Flujos más nuevos / de nicho | Precio del Market |
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](/es/resena-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:
```text
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](https://docs.kie.ai/market/kling/kling-3-0):
```bash
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:
```json
{
"code": 200,
"msg": "success",
"data": {
"taskId": "task_kling-3.0_1765187774173"
}
}
```
Haz polling hasta que termine:
```bash
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`:
```json
{
"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:
```bash
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:
```bash
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](https://docs.kie.ai/veo3-api/generate-veo-3-video):
- 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](/es/agente-imagen-mastra-kie-ai/)):
```bash
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:
```json
{
"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:
```js
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/`:
```js
#!/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:
```bash
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](/es/agente-imagen-mastra-kie-ai/) muestra el mismo patrón como herramientas de TypeScript (`createTask` → `pollTaskUntilDone` → `downloadToGenerated`).
## Qué modelo elegir
| Objetivo | Elige |
|---|---|
| Shorts de YouTube / TikTok 9:16 con audio | Veo 3.1 Fast (9:16 nativo) o Kling 3.0 std 9:16 |
| Clip cinematográfico de producto/marca | Veo 3.1 Quality o Kling 3.0 pro |
| Generación económica por lotes | Seedance 2.0 Mini, Grok Imagine, Veo 3 Fast |
| Historia multi-plano (3+ planos, un video) | Kling 3.0 con `multi_shots: true` |
| Imagen inicial → movimiento (I2V) | Kling 3.0 `image_urls`, Veo `REFERENCE_2_VIDEO` |
| Consistencia de personajes/elementos | Kling 3.0 `kling_elements` + `@element_name` en el prompt |
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:
| Trabajo | Costo aproximado |
|---|---|
| Veo 3 Fast, 8s con audio | ~$0.30–$0.40 |
| Veo 3 Quality, 8s | ~$2.00 |
| Veo 3.1 Quality, 1080p | ~$1.28 |
| Kling 3.0 std, 5s, sin audio | ~$0.35 |
| Kling 3.0 pro, 5s, con audio | ~$0.68 |
| Seedance 2.0 | ~$0.057/s |
| Grok Imagine, 6s | ~$0.10 |
| Hailuo 2.3, 6s | ~$0.15 |
Consulta [kie.ai/pricing](https://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](https://kie.ai/logs) 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](/build-ai-agent-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
Las cuentas nuevas de Kie reciben créditos de prueba, y el Playground te permite probar prompts de video antes de escribir código. Los trabajos de video consumen más créditos que las imágenes (documentación: típicamente 100–500 créditos por generación), así que la prueba cubre un puñado de clips — suficiente para comparar modelos.
Veo 3.1 es la opción más limpia porque 9:16 es una proporción de salida nativa (Fast para volumen, Quality para acabado). Kling 3.0 también soporta 9:16 en los modos std/pro si quieres narrativa multi-plano o referencias de elementos.
Con los precios listados de Kie, Veo 3.1 Quality 1080p ronda $1.28 por video, mientras que Kling 3.0 std cuesta $0.07/s sin audio ($0.35 por 5s) y pro cuesta $0.09/s. Para un clip de 8s en 1080p, Kling std es más barato; para calidad cinematográfica con audio, compara Veo 3.1 Quality vs Kling pro en la página de precios en vivo — la respuesta cambia con la duración y la resolución.
Sí. Sube la imagen al alojamiento de archivos de Kie (subida base64 → `fileUrl`), luego pásala como `image_urls[0]` para Kling (fotograma inicial, o fotogramas de inicio + fin) o `imageUrls` con `generationType: "REFERENCE_2_VIDEO"` para Veo 3.1.
Poco. La documentación recomienda descargar de inmediato porque las URLs de contenido generado suelen expirar tras ~24 horas. Los registros de tareas permanecen ~2 meses y los medios ~14 días en tu cuenta, pero tu pipeline debería llevar el archivo a tu propio almacenamiento en cuanto haya éxito.
La plataforma afirma que las tareas fallidas no se cobran. Mi consejo: verifica igualmente `creditsConsumed` en el registro de la tarea tras los primeros fallos, y revisa la razón del fallo en `failMsg` / la página de registros antes de reintentar el mismo prompt.
## 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.