TL;DR: Kenerate AI es un espacio de trabajo creativo que combina capacidades de imagen, video, edición, audio, 3D y agentes.

Kenerate AI reúne herramientas creativas en un solo espacio de trabajo. Los desarrolladores deben distinguir primero sus opciones de acceso nativas, incluidas MCP/CLI y el acceso a la API para empresas, de una integración separada con CometAPI. Esta guía abarca el acceso y la planificación de costos, la configuración del entorno, la generación de imágenes, el manejo de respuestas, la edición de imágenes y la creación asíncrona de videos. Sigue los ejemplos para guardar una imagen original, una variante editada y un clip finalizado usando Python 3.10+, una clave de CometAPI y saldo suficiente.

Puntos clave

• Kenerate AI es un servicio creativo multimodelo, no un único modelo fundacional.
• Kenerate ofrece acceso vía MCP/CLI y también incorporación a una API para empresas; elige la ruta que se ajuste a tu aplicación y a tu cuenta.
• Usa IDs de modelo concretos y parámetros específicos de la ruta al crear una integración separada con CometAPI.
• Guarda los bytes de la imagen tras la generación; conserva el ID de la tarea de video para que el sondeo pueda reanudarse sin enviar otro trabajo.
• CometAPI ofrece una integración para desarrolladores separada para los modelos de imagen/video compatibles, con credenciales y facturación independientes.

¿Qué es Kenerate AI?

Usa los estudios de Kenerate para creación interactiva. Los desarrolladores también pueden usar sus herramientas oficiales MCP/CLI o contactar con soporte para el acceso a la API para empresas. La sección de acceso a continuación explica estas opciones; los ejemplos en Python más adelante en esta guía llaman a CometAPI por separado.

Kenerate AI y CometAPI son servicios separados.

El código de abajo llama directamente a CometAPI. No inicia sesión en Kenerate, no automatiza un estudio de Kenerate ni consume créditos de Kenerate. Recrea una tarea creativa de alcance limitado usando un modelo compatible, en lugar de producir resultados idénticos a los del estudio.

Ejemplo oficial de imagen de producto de la galería de Kenerate. Ilustra un caso de uso creativo; no es el resultado del código de API de abajo.

¿Cómo afecta el precio de Kenerate AI a la planificación de costos de la API?

Kenerate anuncia 25 créditos iniciales y paquetes de créditos de pago único desde $15. Su FAQ de facturación indica que los créditos comprados no caducan y que la generación de video requiere un paquete de créditos comprado. Estos son términos de facturación del estudio, no una cotización para el acceso a la API empresarial.

CometAPI usa credenciales y facturación separadas. Antes de una prueba o un lote, compara el modelo seleccionado y la configuración de la solicitud con su estimación de costos, establece un límite de trabajos e inspecciona el uso registrado. Los créditos de Kenerate no determinan el costo de las solicitudes a CometAPI.

¿Cómo acceder a Kenerate AI?

Conectar mediante MCP o CLI

La página oficial de configuración MCP/CLI de Kenerate proporciona una vía nativa para desarrolladores. Su servidor MCP remoto es https://mcp.kenerateai.com/mcp. Agrega el servidor en un cliente compatible y completa el inicio de sesión de Kenerate donde esté disponible; sigue la página de configuración para la instalación y autenticación del CLI. Estas herramientas usan tu cuenta de Kenerate, no una clave de CometAPI.

Solicita acceso a la API para empresas cuando sea necesario

El FAQ oficial también describe el acceso a la API para socios Enterprise a través de soporte. Para esa ruta, solicita documentación de endpoints, autenticación, operaciones admitidas, cuotas y términos de facturación. La incorporación empresarial no debe presentarse como la única opción de integración nativa.

¿Cómo configurar un flujo de trabajo separado con CometAPI?

Cuenta y credenciales

Crea una cuenta en CometAPI y genera una clave siguiendo las instrucciones de configuración de la clave de API. Conserva la clave en tu servidor o máquina de desarrollo. Los siguientes comandos de Bash instalan el cliente HTTP y leen la clave sin mostrarla. Los usuarios de Windows pueden ejecutarlos en WSL o Git Bash.

python -m pip install requests
read -rsp "CometAPI API key: " COMETAPI_KEY
export COMETAPI_KEY
printf '\n'

Una primera solicitud pequeña y específica

Usa un solo prompt y una sola salida antes de añadir controles opcionales. Para el flujo de imagen, los desarrolladores pueden acceder a la API GPT Image 2 en CometAPI. El flujo de video usa la Kling Video API en CometAPI con el valor model_name específico de la ruta de su inicio rápido para desarrolladores. Una etiqueta del estudio no sustituye a un identificador de API.

Comparar los ejemplos de CometAPI

CometAPI documenta por separado la solicitud y los campos de salida de imagen, y las rutas de envío y sondeo de video. Trata credenciales, ruta, cuerpo y análisis del resultado como una integración completa.

¿Puedes usar el SDK de OpenAI con CometAPI?

Sí, para rutas compatibles con OpenAI. La guía del SDK de CometAPI usa una clave de CometAPI y la base URL https://api.cometapi.com/v1. El SDK de Python de OpenAI admite un base_url personalizado. Instala el SDK por separado si decides usarlo; los scripts ejecutables de imagen y video más abajo usan requests.

python -m pip install openai

import os
from openai import OpenAI

client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)

Client configuration only: no generation request is submitted here.

La compatibilidad se aplica al endpoint documentado, los campos y la forma de la respuesta. No hace que todas las rutas de proveedores sean intercambiables. El inicio rápido de imagen es compatible con client.images.generate; el ejemplo de Kling a continuación usa su ruta específica del proveedor /kling/v1/videos/text2video y su contrato de tarea. Sigue el inicio rápido correspondiente de [imagen](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) o de [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) en lugar de sustituirlo por una llamada de video genérica del SDK.

## ¿Cómo generar y guardar una imagen con CometAPI?

### Elegir la configuración de imagen

Para la primera prueba de imagen, usa gpt-image-2, size="1024x1024", quality="low" y output_format="jpeg". Guarda el resultado con una extensión de archivo coincidente. Describe claramente el producto, el fondo y la iluminación. Esta ruta de imagen usa el campo model y devuelve los bytes de imagen en data[0].b64_json.

### Generar y guardar la imagen

CometAPI documenta la generación de imágenes con [gpt-image-2](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) y salida en base64. Este ejemplo envía una solicitud síncrona y guarda los bytes devueltos como un JPEG. Guárdalo como generate_image.py y ejecuta python generate_image.py después de establecer la variable de entorno.

import base64
import os
from pathlib import Path
import requests

response = requests.post(
"https://api.cometapi.com/v1/images/generations",
headers={"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"},
json={
"model": "gpt-image-2",
"prompt": "A ceramic cup on marble, realistic product lighting",
"quality": "low",
"size": "1024x1024",
"output_format": "jpeg",
},
timeout=(10, 180),
)
response.raise_for_status()
payload = response.json()
items = payload.get("data", [])
if not items or not items[0].get("b64_json"):
raise RuntimeError("No image bytes returned; inspect the response schema.")
image_bytes = base64.b64decode(items[0]["b64_json"], validate=True)
if not image_bytes:
raise RuntimeError("The returned image is empty.")
output = Path("product-image.jpeg")
output.write_bytes(image_bytes)
print(f"Saved {output} ({len(image_bytes)} bytes)")

### Comprobar la imagen guardada

Primero confirma que `product-image.jpeg` existe y se abre en un visor de imágenes. Luego comprueba si su sujeto, composición y detalles del producto coinciden con el prompt. Inspecciona el sujeto y la composición antes de cambiar el prompt. Un estado HTTP 200 confirma que la solicitud se realizó correctamente, pero aún debes validar los datos devueltos e inspeccionar la imagen. Si una respuesta contiene un error o un esquema diferente, examínalo antes de cambiar el decodificador; no guardes el texto JSON con una extensión de imagen.

Mantén la imagen original sin cambios para ediciones posteriores. Haz coincidir la extensión del archivo con el output_format solicitado e inspecciona visualmente texto o detalles importantes del producto. Si cambias de modelo, verifica su contrato de respuesta antes de reutilizar este decodificador base64.

### Editar una imagen generada o local

Sube el archivo de origen como datos multipart. Indica el cambio solicitado y los detalles que deben preservarse; conserva el archivo original y guarda cada resultado aprobado con un nombre nuevo.

Para el flujo separado con CometAPI, el [endpoint de edición de imagen acepta cargas multipart](https://apidoc.cometapi.com/api/image/openai/image-editing). Guarda este script independiente como edit_image.py junto a product-image.jpeg del paso de generación y luego ejecuta python edit_image.py. El prompt solicita un único cambio en el color de la taza, y el script guarda el resultado como `product-image-edited.jpeg`.

import base64
import os
from pathlib import Path
import requests

source = Path("product-image.jpeg")
with source.open("rb") as image_file:
response = requests.post(
"https://api.cometapi.com/v1/images/edits",
headers={"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"},
files={"image": (source.name, image_file, "image/jpeg")},
data={
"model": "gpt-image-2",
"prompt": "Change only the cup color to matte black. Preserve its shape, background and lighting.",
"quality": "low",
"output_format": "jpeg",
},
timeout=(10, 240),
)
response.raise_for_status()
items = response.json().get("data", [])
if not items or not items[0].get("b64_json"):
raise RuntimeError("No edited image returned; inspect the response.")
edited_bytes = base64.b64decode(items[0]["b64_json"], validate=True)
if not edited_bytes:
raise RuntimeError("The edited image is empty.")
Path("product-image-edited.jpeg").write_bytes(edited_bytes)
print("Saved product-image-edited.jpeg")

#### Uso de una imagen de referencia local

Para editar una foto de producto existente, establece source en ese archivo. Configura el tipo MIME de la carga para que coincida con su formato real, como image/png para un PNG. El output_format solicitado puede seguir siendo jpeg independientemente del formato de origen. Permite que requests genere la cabecera Content-Type multipart; forzar manualmente application/json rompería la carga del archivo.

Las imágenes de referencia ayudan con la consistencia pero no garantizan la preservación exacta de logotipos o la geometría del producto. Mantén un paso de aprobación humana para afirmaciones comerciales sobre productos.

#### Continuar una edición

Para otra edición, sube la salida aprobada como el siguiente origen y redacta la siguiente instrucción. Conserva cada versión con un nombre de archivo diferente. Revisa tanto el cambio solicitado como los elementos que deben permanecer sin cambios antes de continuar.

## ¿Cómo enviar y recuperar un video de Kling con CometAPI?

### Enviar una tarea de video

El inicio rápido de texto a video de [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) usa una tarea asíncrona: envía una vez, conserva el ID y consulta la ruta correspondiente. El ejemplo siguiente usa `model_name="kling-v3"`, `mode="std"`, `duration="5"` y `sound="off"`. Estos valores aplican a esta ruta de Kling en CometAPI. Describe una acción clara de un solo sujeto y el movimiento de cámara previsto.

Usa model_name para esta ruta específica del proveedor y mantén mode="std", duration="5" y sound="off" para la primera prueba. Guarda inmediatamente el task_id devuelto. Esta es una solicitud de texto a video; las referencias de imagen requieren la ruta documentada de imagen a video del proveedor seleccionado.

Guarda el código como generate_video.py. Ejecuta python generate_video.py para crear una tarea. Después de una interrupción del sondeo, ejecuta python generate_video.py TASK_ID usando el ID guardado para reanudar. El [contrato de recuperación de tareas](https://apidoc.cometapi.com/api/video/kling/individual-queries) documenta la URL del resultado y admite tanto un contenedor data como un objeto de tarea directo.

### Sondear la tarea y descargar el resultado

Una respuesta de creación de video proporciona un ID de tarea, no un archivo multimedia terminado. Guarda el ID con el trabajo, inspecciona task_status al recuperar y descarga el resultado solo después del éxito. El script completo de video de abajo gestiona el envío, el sondeo, los fallos y la descarga; su modo de reanudación reutiliza el mismo trabajo.

Recupera la tarea existente con GET /kling/v1/videos/text2video/{task_id}. Espera a task_status="succeed" antes de leer task_result.videos[0].url; trata "failed" como un error. Un tiempo de espera local de sondeo debe preservar el ID de la tarea para que la recuperación pueda reanudarse sin enviar otra generación.

import json
import os
import sys
import time
from pathlib import Path
import requests

route = "https://api.cometapi.com/kling/v1/videos/text2video"
headers = {"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"}

def read_task(response):
response.raise_for_status()
body = response.json()
if body.get("code") not in (None, 0):
raise RuntimeError(f"API error: {body.get('message', body.get('code'))}")
return body.get("data", body)

if len(sys.argv) > 1:
task_id = sys.argv[1]
else:
created = read_task(requests.post(
route, headers=headers,
json={
"model_name": "kling-v3",
"prompt": "A wristwatch on dark marble. Slow lateral camera motion, soft light, no cuts.",
"mode": "std", "duration": "5", "sound": "off",
}, timeout=(10, 60),
))
task_id = created["task_id"]
Path("video-task-id.txt").write_text(task_id, encoding="utf-8")
print(f"Task ID: {task_id}", flush=True)

deadline = time.monotonic() + 600
while time.monotonic() < deadline:
task = read_task(requests.get(
f"{route}/{task_id}", headers=headers, timeout=(10, 30),
))
state = task["task_status"]
if state == "failed":
raise RuntimeError(task.get("task_status_msg") or "Video task failed")
if state == "succeed":
Path("video-result.json").write_text(json.dumps(task), encoding="utf-8")
asset_url = task["task_result"]["videos"][0]["url"]
with requests.get(asset_url, stream=True, timeout=(10, 120)) as asset:
asset.raise_for_status()
with Path("product-video.mp4").open("wb") as output:
for chunk in asset.iter_content(chunk_size=1024 * 1024):
if chunk:
output.write(chunk)
print("Saved product-video.mp4")
break
time.sleep(5)
else:
raise TimeoutError(f"Polling stopped. Resume with task ID {task_id}.")

### Finalización y recuperación

Abre product-video.mp4 y confirma que se reproduce completo. El script guarda el resultado de la tarea antes de descargar, por lo que un fallo en la descarga no requiere generar otro clip. Su plazo local de sondeo detiene la espera; no cancela la tarea remota. Conserva el ID y reanuda la recuperación. La descarga del recurso usa deliberadamente una solicitud separada sin autenticación para no enviar la clave de CometAPI al host de medios.

El ejemplo de video usa entrada de texto. No se puede adjuntar una imagen aprobada inventando un campo reference_image en esta ruta; imagen a video requiere el flujo de trabajo de imagen documentado por el proveedor seleccionado.

## ¿Cómo ampliar un flujo de trabajo de CometAPI para producción?

### Registros de trabajos y recursos reutilizables

Guarda cada prompt, configuración, recurso de origen, ID de tarea y ruta de salida bajo un mismo trabajo de la aplicación. Mantén las revisiones de imágenes por separado para que los usuarios puedan volver a una versión aprobada. Para video, persiste el ID de la tarea antes de salir del controlador de la solicitud y permite que un worker gestione la recuperación.

### Callbacks y conciliación

Para la entrega asíncrona de video, sigue la [guía de sondeo y webhooks de CometAPI](https://apidoc.cometapi.com/guides/webhook-and-polling-for-video-generation). Agrega callbacks solo después de que el sondeo básico funcione y haz que las notificaciones duplicadas sean seguras de procesar. Conserva una vía de recuperación para trabajos cuyo callback se retrase o se pierda.

## ¿Cómo deberías manejar errores en un flujo de trabajo de CometAPI?

Aplica la [guía documentada de errores de API y estrategia de reintentos](https://apidoc.cometapi.com/guides/error-codes-and-retry-strategy) al construir este flujo de trabajo con CometAPI. Primero separa una solicitud inválida de un fallo de transporte temporal. Conserva en los registros del servidor el estado de la respuesta, los identificadores de la solicitud y los IDs de tarea, excluyendo las claves secretas.

* Error de autenticación: verifica la clave, el acceso de la cuenta y el host de destino antes de reintentar.
* Parámetro no admitido: vuelve a la solicitud documentada más pequeña y luego agrega un campo opcional a la vez.
* Límite de tasa o fallo de sondeo transitorio: espera con retroceso acotado y reanuda la consulta de la tarea existente.
* Tiempo de espera en la creación: determina si la primera solicitud creó un trabajo antes de enviar otra. Repetir una solicitud de generación puede generar un cargo adicional.
* Descarga de salida fallida: usa el resultado de tarea conservado o recupera la tarea existente de nuevo en lugar de iniciar una nueva generación.

## Conclusión

Elige primero el servicio y la ruta de acceso. Para Kenerate, comienza con la configuración oficial de MCP/CLI o habla con soporte sobre los requisitos de la API empresarial. Para una implementación separada con CometAPI, configura su clave, sigue la ruta de imagen o de Kling, inspecciona los resultados guardados y conserva los IDs de tareas de video para recuperación. Un hito útil inicial es una imagen local válida, una variante editada y un video reproducible.

## Preguntas frecuentes

### ¿Puede este flujo de trabajo de CometAPI ejecutarse totalmente en un navegador?

Un navegador puede presentar prompts y progreso, pero un frontend público no debe contener una clave de API secreta. Coloca las solicitudes de generación y el seguimiento de tareas detrás de tu propio backend, autentica al usuario allí y devuelve solo el resultado o el progreso que la interfaz necesita. Una implementación separada con CometAPI debe seguir esa misma separación.

### ¿Qué debe solicitar un equipo antes de la incorporación empresarial de Kenerate AI?

Solicita la documentación nativa de la API y una descripción por escrito de los modelos y operaciones disponibles para tu cuenta. También resuelve autenticación, cuotas, facturación, retención de tareas y la propiedad del soporte. Una demostración del estudio establece una capacidad creativa, pero no establece el esquema de solicitud ni los términos del servicio que recibirá tu aplicación.

### ¿Producirá el mismo prompt de Kenerate AI un resultado idéntico en la API?

No confíes en ello. Primero alinea la versión exacta del modelo, los recursos de entrada y la configuración de generación expuesta. Un estudio puede añadir valores predeterminados o procesamiento que tu solicitud de API no reproduzca. Conserva el brief y los recursos de referencia aprobados, y luego revisa la nueva salida contra los requisitos reales de entrega en lugar de esperar medios idénticos píxel a píxel.