Guía rápida de la API Kling V3.0 4K

Kling V3.0 4K está disponible en Novita AI como dos endpoints de API dedicados: kling-v3.0-4k-t2v para texto a video y kling-v3.0-4k-i2v para imagen a video. Ambos producen salida nativa de 3840×2160, admiten duraciones de 3 a 15 segundos y siguen el mismo patrón de tareas asíncronas utilizado en todas las APIs de video de Novita. Si ya tienes Kling V3.0 Standard o Pro en tu flujo, cambiar al nivel 4K es un cambio de ID de modelo en una sola línea.

Esta guía cubre solo los endpoints específicos de 4K. Para generación de audio nativa, composición de múltiples tomas o precios por segundo de Standard/Pro, consulta la descripción general de Kling 3.0 en Novita AI.

Cuándo usar Kling V3.0 4K frente a Standard y Pro

El nivel 4K tiene sentido cuando la resolución de salida es la limitación: activos con calidad de impresión, pantallas grandes o flujos de trabajo posteriores que requieren fotogramas fuente de alta resolución para composición o recorte.

No reemplaza a Standard o Pro para todos los casos de uso. La iteración y las pruebas de prompts son más baratas en resoluciones más bajas, y la generación en 4K lleva más tiempo por tarea. Un flujo de trabajo práctico es iterar con Standard y luego cambiar a kling-v3.0-4k-t2v o kling-v3.0-4k-i2v para el prompt final aceptado.

Usa kling-v3.0-4k-t2v cuando:

• La escena sea completamente describible en un prompt
• No exista o no importe una imagen de referencia

Usa kling-v3.0-4k-i2v cuando:

• Un primer fotograma específico deba anclar el clip generado
• Necesites una apariencia de sujeto consistente a partir de una imagen fuente

Paso 1: Obtén tu clave de API de Novita AI

Regístrate en novita.ai y genera una clave de API desde el panel de control. Las cuentas nuevas incluyen créditos gratuitos. Almacena la clave como una variable de entorno; no la codifiques directamente en los archivos fuente.

export NOVITA_API_KEY="tu_clave_api_aqui"

Paso 2: IDs de modelo y endpoints

Modo	ID de modelo	Endpoint
Texto a Video	kling-v3.0-4k-t2v	POST https://api.novita.ai/v3/async/kling-v3.0-4k-t2v
Imagen a Video	kling-v3.0-4k-i2v	POST https://api.novita.ai/v3/async/kling-v3.0-4k-i2v
Obtención de resultados	—	GET https://api.novita.ai/v3/async/task-result?task_id=<id>

Ambos endpoints aceptan JSON, requieren un token Bearer en el encabezado Authorization y devuelven un task_id de inmediato. El video real se recupera por separado desde el endpoint de resultado de tarea.

Referencias oficiales de la API:

• Documentación de Kling v3.0 4K T2V
• Documentación de Kling v3.0 4K I2V

Paso 3: Envía tu primera solicitud

curl -X POST https://api.novita.ai/v3/async/kling-v3.0-4k-t2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Un faro solitario en una costa rocosa durante la hora dorada, plano general cinemático, olas rompiendo",
    "negative_prompt": "borroso, baja calidad, distorsionado",
    "duration": 5,
    "aspect_ratio": "16:9",
    "cfg_scale": 0.5
  }'

La respuesta devuelve un task_id:

{
  "task_id": "t2v-kling-4k-abc123"
}

Guarda ese ID; lo necesitarás para recuperar el resultado.

Paso 4: Consulta el resultado del video

curl "https://api.novita.ai/v3/async/task-result?task_id=t2v-kling-4k-abc123" \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Una tarea completada devuelve un objeto task con status: "TASK_STATUS_SUCCEED" y un array videos:

{
  "task": {
    "task_id": "t2v-kling-4k-abc123",
    "status": "TASK_STATUS_SUCCEED"
  },
  "videos": [
    {
      "video_url": "https://...",
      "video_url_ttl": 3600,
      "video_type": "mp4"
    }
  ]
}

Valores típicos de estado: TASK_STATUS_QUEUED, TASK_STATUS_PROCESSING, TASK_STATUS_SUCCEED, TASK_STATUS_FAILED. Construye tu bucle de consulta alrededor de estos; no supongas un tiempo de espera fijo, ya que la generación en 4K lleva más tiempo que en 1080P.

Paso 5: Solicitud de imagen a video

El endpoint de imagen a video requiere un image_url además de prompt. La imagen define el primer fotograma; el modelo genera movimiento a partir de ella.

curl -X POST https://api.novita.ai/v3/async/kling-v3.0-4k-i2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "El haz del faro barre la niebla, movimiento lento y dramático",
    "negative_prompt": "cortes rápidos, sacudidas, baja calidad",
    "image_url": "https://tu-almacenamiento.ejemplo.com/faro-fotograma.jpg",
    "duration": 5,
    "aspect_ratio": "16:9",
    "cfg_scale": 0.5
  }'

Requisitos de imagen (verifica los límites actuales en la referencia de API de Novita):

• Formatos: .jpg, .jpeg, .png
• Tamaño máximo de archivo: 10 MB
• Dimensiones mínimas: 300×300 píxeles

El paso de obtención del resultado es idéntico al T2V: consulta /v3/async/task-result con el task_id devuelto.

Ejemplos en Python

T2V — texto a video 4K

import os
import time
import requests

API_KEY = os.environ["NOVITA_API_KEY"]
BASE_URL = "https://api.novita.ai"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

def submit_t2v(prompt: str, duration: int = 5, aspect_ratio: str = "16:9") -> str:
    payload = {
        "prompt": prompt,
        "negative_prompt": "borroso, baja calidad",
        "duration": duration,
        "aspect_ratio": aspect_ratio,
        "cfg_scale": 0.5,
    }
    resp = requests.post(
        f"{BASE_URL}/v3/async/kling-v3.0-4k-t2v",
        headers=HEADERS,
        json=payload,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()["task_id"]

def poll_result(task_id: str, interval: int = 10, max_wait: int = 600) -> dict:
    deadline = time.time() + max_wait
    while time.time() < deadline:
        resp = requests.get(
            f"{BASE_URL}/v3/async/task-result",
            headers=HEADERS,
            params={"task_id": task_id},
            timeout=30,
        )
        resp.raise_for_status()
        data = resp.json()
        status = data.get("task", {}).get("status", "")
        if status == "TASK_STATUS_SUCCEED":
            return data
        if status == "TASK_STATUS_FAILED":
            raise RuntimeError(f"Tarea fallida: {data}")
        time.sleep(interval)
    raise TimeoutError(f"La tarea {task_id} no se completó en {max_wait}s")

if __name__ == "__main__":
    task_id = submit_t2v(
        prompt="Un faro solitario en una costa rocosa durante la hora dorada, plano general cinemático",
        duration=5,
        aspect_ratio="16:9",
    )
    print(f"Tarea enviada: {task_id}")
    result = poll_result(task_id)
    video_url = result["videos"][0]["video_url"]
    print(f"Video listo: {video_url}")

I2V — imagen a video 4K

def submit_i2v(
    prompt: str,
    image_url: str,
    duration: int = 5,
    aspect_ratio: str = "16:9",
) -> str:
    payload = {
        "prompt": prompt,
        "negative_prompt": "borroso, baja calidad",
        "image_url": image_url,
        "duration": duration,
        "aspect_ratio": aspect_ratio,
        "cfg_scale": 0.5,
    }
    resp = requests.post(
        f"{BASE_URL}/v3/async/kling-v3.0-4k-i2v",
        headers=HEADERS,
        json=payload,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()["task_id"]

Usa la misma función poll_result para recuperar el video generado.

Parámetros clave

Parámetro	Tipo	Requerido	Notas
prompt	string	Sí	Descripción de la escena. Sé específico: sujeto, movimiento, ángulo de cámara, iluminación.
negative_prompt	string	No	Qué suprimir: borroso, sacudidas, artefactos, estilos no deseados.
duration	integer	No	Segundos de video. Rango: 3–15. El valor predeterminado varía; consulta la documentación.
aspect_ratio	string	No	"16:9", "9:16", "1:1". Valor predeterminado: "16:9".
cfg_scale	float	No	Fuerza de adherencia al prompt. 0.5 es un valor inicial seguro.
image_url	string	Solo I2V	Imagen del primer fotograma. Debe ser una URL accesible públicamente.

Resolución y duración vs. costo

La generación en 4K cuesta más por segundo que Standard o Pro. Antes de comprometerte con un lote completo:

• Prueba prompts con kling-v3.0-std-t2v con duration: 3
• Cambia a kling-v3.0-4k-t2v solo para los prompts aceptados
• Usa duration: 5 para la mayoría de las salidas; reserva 10–15 segundos para clips destacados

Precios y estimaciones de costos

Novita AI utiliza facturación por segundo para Kling V3.0 4K. El precio del nivel 4K es más alto que el de Standard o Pro; consulta novita.ai/models/kling/kling-v3.0-4k-t2v y novita.ai/models/kling/kling-v3.0-4k-i2v para conocer las tarifas actuales por segundo antes de ejecutar lotes en producción.

Para contexto sobre los niveles Standard y Pro, la descripción general de Kling 3.0 documenta las tarifas por segundo para esos niveles. El nivel 4K tiene un precio independiente.

Patrón de estimación de costos para cualquier modelo por segundo:

• Determina la duración por clip (ej. 5 segundos)
• Multiplica por la tarifa por segundo
• Multiplica por el número esperado de clips aceptados
• Agrega un margen de reintento (10–20% para fallos de prompt)

Solución de problemas

task_id recibido pero el resultado nunca tiene éxito Las tareas 4K tardan más que las equivalentes en 1080P. Extiende el tiempo de espera de tu consulta a al menos 10 minutos (max_wait=600). Si la tarea permanece en TASK_STATUS_PROCESSING más allá de eso, consulta la página de estado de Novita o reintenta la solicitud.

TASK_STATUS_FAILED sin detalles Las causas más comunes son: prompt que contiene contenido no permitido, un image_url no válido o inaccesible en modo I2V, o un valor de duración fuera del rango admitido. Valida las entradas y reintenta con un prompt más simple.

Imagen I2V rechazada Verifica que la imagen sea accesible públicamente mediante una URL directa (sin redirección ni muro de autenticación), que el formato sea .jpg/.jpeg/.png, que el archivo tenga menos de 10 MB y que las dimensiones sean al menos 300×300 píxeles.

Resolución de salida inesperada Los endpoints 4K apuntan a 3840×2160. Si tu reproductor o herramienta posterior reporta una resolución más baja, verifica si está decodificando el archivo correctamente. La salida codificada de la API debería ser 4K nativo.

Errores de límite de tasa Novita AI aplica límites de tasa por clave de API. Para cargas de trabajo por lotes de alto rendimiento, consulta la documentación de límites de tasa y considera enviar tareas secuencialmente o con un pequeño retraso entre solicitudes.

Preguntas frecuentes

¿Qué resolución produce kling-v3.0-4k-t2v?

Ambos endpoints 4K apuntan a salida nativa de 3840×2160 (4K UHD). Esto es un renderizado de hardware, no una ampliación desde una resolución más baja.

¿Cómo se diferencia Kling V3.0 4K de V3.0 Standard y Pro?

Standard y Pro generan salida en 1080P. Los endpoints 4K añaden resolución nativa de 3840×2160. Standard es el más rápido y económico; Pro añade mayor calidad visual a un costo moderado; 4K es la opción de mayor resolución y tiene un precio acorde. La duración (3–15 segundos) y la forma de la API asíncrona son las mismas en los tres niveles.

¿Puedo usar los endpoints 4K con la misma clave de API que Standard y Pro?

Sí. Todos los endpoints de Kling V3.0 en Novita AI usan la misma autenticación con token Bearer. El único cambio entre niveles es el ID del modelo y la ruta del endpoint.

¿Kling V3.0 4K admite generación de audio nativa?

El indicador estándar de co-generación de audio disponible en los endpoints V3.0 Standard y Pro también puede ser compatible en el nivel 4K. Consulta las páginas de referencia de la API T2V e I2V para la lista actual de parámetros, incluyendo cualquier campo with_audio.

¿Cuánto tiempo lleva una tarea de generación en 4K?

La generación en 4K lleva más tiempo que en 1080P. Espera al menos 60–180 segundos para un clip de 5 segundos, dependiendo de la carga de la cola. Diseña tu lógica de consulta con un tiempo de espera de al menos 10 minutos y maneja TASK_STATUS_PROCESSING como un estado intermedio normal.

¿Es útil el endpoint I2V para footage de productos o marcas?

Sí, cuando la imagen de entrada es limpia y bien iluminada. El endpoint I2V preserva bien la composición del primer fotograma para sujetos estáticos. Para movimientos de cámara complejos o escenas con múltiples personajes, ejecuta un pequeño lote de prueba antes de una producción completa.

Artículos recomendados

• Kling 3.0 ya en Novita AI: Generación de video AI cinematográfica a escala
• Kling O1 en Novita AI: Modos T2V, I2V, Ref2V y Edición de Video
• API Kling V2.5 Turbo en Novita AI: Texto a Video e Imagen a Video