TL;DR: Kenerate AI é um espaço de trabalho criativo que combina recursos de imagem, vídeo, edição, áudio, 3D e agentes.

Kenerate AI reúne ferramentas criativas em um único workspace. Desenvolvedores devem primeiro distinguir suas opções de acesso nativo, incluindo MCP/CLI e acesso à API para Enterprise, de uma integração separada via CometAPI. Este guia aborda acesso e planejamento de custos, configuração de ambiente, geração de imagem, tratamento de respostas, edição de imagem e criação assíncrona de vídeo. Siga os exemplos para salvar uma imagem original, uma variante editada e um clipe concluído usando Python 3.10+, uma chave da CometAPI e saldo suficiente.

Principais pontos

Kenerate AI é um serviço multimodelo de criação, não um único modelo base.
A Kenerate oferece acesso via MCP/CLI e onboarding de API para Enterprise; escolha a rota que corresponda ao seu aplicativo e à sua conta.
Use IDs de modelo concretos e parâmetros específicos da rota ao criar uma integração separada com a CometAPI.
Salve os bytes da imagem após a geração; mantenha um ID de tarefa de vídeo para que o polling possa ser retomado sem enviar outro job.
A CometAPI oferece uma integração de desenvolvedor separada para modelos de imagem/vídeo suportados, com credenciais e cobrança separadas.

O que é o Kenerate AI?

Use os estúdios do Kenerate para criação interativa. Desenvolvedores também podem usar suas ferramentas oficiais MCP/CLI ou entrar em contato com o suporte sobre acesso à API para Enterprise. A seção de acesso abaixo explica essas opções; os exemplos em Python mais adiante neste guia chamam a CometAPI separadamente.

Kenerate AI e CometAPI são serviços distintos.

O código abaixo chama a CometAPI diretamente. Ele não faz login no Kenerate, não automatiza um estúdio do Kenerate e não gasta créditos do Kenerate. Ele recria uma tarefa criativa de escopo reduzido usando um modelo suportado, em vez de reivindicar presets ou resultados idênticos aos do estúdio.

Como usar o Kenerate AI: imagens, vídeos, API & preços

Exemplo oficial de imagem de produto da galeria da Kenerate. Isso ilustra um caso de uso criativo; não é a saída do código de API abaixo.

Como o preço do Kenerate AI afeta o planejamento de custo da API?

A Kenerate anuncia 25 créditos iniciais e pacotes de créditos avulsos a partir de US$ 15. Sua FAQ de cobrança diz que créditos comprados não expiram e que a geração de vídeo requer um pacote de créditos adquirido. Estes são termos de cobrança do estúdio, não uma cotação para acesso à API Enterprise.

A CometAPI usa credenciais e cobrança separadas. Antes de um teste ou lote, verifique o modelo selecionado e as configurações da solicitação em relação à sua estimativa de custo, defina um limite de jobs e inspecione o uso registrado. Créditos do Kenerate não determinam o custo das solicitações na CometAPI.

Como acessar o Kenerate AI?

Conecte-se via MCP ou CLI

A página oficial de configuração MCP/CLI do Kenerate fornece uma rota nativa para desenvolvedores. Seu servidor MCP remoto é https://mcp.kenerateai.com/mcp. Adicione o servidor em um cliente compatível e conclua o login no Kenerate quando suportado; siga a página de configuração para instalação e autenticação da CLI. Essas ferramentas usam sua conta Kenerate, e não uma chave da CometAPI.

Solicite acesso à API Enterprise quando necessário

A FAQ oficial também descreve acesso à API para parceiros Enterprise via suporte. Para essa rota, solicite documentação de endpoints, autenticação, operações suportadas, cotas e termos de cobrança. O onboarding para Enterprise não deve ser apresentado como a única opção de integração nativa.

Como configurar um fluxo de trabalho separado com a CometAPI?

Conta e credenciais

Crie uma conta na CometAPI e gere uma chave usando as instruções de configuração de chave de API. Mantenha a chave no seu servidor ou máquina de desenvolvimento. Os comandos Bash a seguir instalam o cliente HTTP e leem a chave sem exibi-la. Usuários do Windows podem executá-los no WSL ou Git Bash.

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

Um primeiro pedido pequeno e específico

Use um prompt e uma saída antes de adicionar controles opcionais. Para o fluxo de imagem, os desenvolvedores podem acessar a GPT Image 2 API na CometAPI. O fluxo de vídeo usa a Kling Video API na CometAPI com o valor model_name específico da rota de seu guia rápido para desenvolvedores. Um rótulo do estúdio não substitui um identificador de API.

Compare os exemplos da CometAPI

Detalhe de integração	Geração de imagem na CometAPI	Vídeo Kling na CometAPI
Autenticação	Bearer COMETAPI_KEY	Bearer COMETAPI_KEY
Caminho de criação	/v1/images/generations	/kling/v1/videos/text2video
Seletor de modelo	model	model_name
Conclusão	Resposta síncrona	Tarefa assíncrona; faça polling da rota correspondente
Saída	Decodifique data[0].b64_json	Faça download de task_result.videos[0].url após sucesso

A CometAPI documenta separadamente os campos de solicitação e saída de imagem e as rotas de submissão e polling de vídeo. Trate credenciais, rota, corpo e parsing de resultados como uma integração completa.

Você pode usar o SDK da OpenAI com a CometAPI?

Sim, para rotas compatíveis com OpenAI suportadas. O guia do SDK da CometAPI usa uma chave da CometAPI e a base URL https://api.cometapi.com/v1. O SDK Python da OpenAI suporta um base_url personalizado. Instale o SDK separadamente se optar por ele; os scripts executáveis de imagem e vídeo abaixo usam 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.


A compatibilidade se aplica ao endpoint documentado, campos e formato da resposta. Isso não torna todas as rotas de provedores intercambiáveis. O guia rápido de imagem suporta client.images.generate; o exemplo do Kling abaixo usa sua rota específica do provedor /kling/v1/videos/text2video e seu contrato de tarefa. Siga o guia rápido correspondente de [imagem](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) ou [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) em vez de substituir por uma chamada genérica de vídeo do SDK.

## Como gerar e salvar uma imagem com a CometAPI?

### Escolher as configurações de imagem

Para o primeiro teste de imagem, use gpt-image-2, size="1024x1024", quality="low" e output_format="jpeg". Salve o resultado com uma extensão de arquivo correspondente. Descreva claramente o produto, o fundo e a iluminação. Esta rota de imagem usa o campo model e retorna os bytes da imagem em data[0].b64_json.

### Gerar e salvar a imagem

A CometAPI documenta a geração de imagem com o [gpt-image-2](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) e saída em base64. Este exemplo envia uma solicitação síncrona e salva os bytes retornados como JPEG. Salve como generate_image.py e execute python generate_image.py após definir a variável de ambiente.

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


### Verificar a imagem salva

Primeiro, confirme que `product-image.jpeg` existe e abre em um visualizador de imagens. Em seguida, verifique se seu assunto, composição e detalhes do produto correspondem ao prompt. Inspecione o assunto e a composição antes de alterar o prompt. Uma resposta HTTP 200 confirma que a solicitação foi bem-sucedida, mas você ainda precisa validar os dados retornados e inspecionar a imagem. Se uma resposta contiver um erro ou um esquema diferente, inspecione-o antes de alterar o decodificador; não salve o texto JSON com uma extensão de imagem.

Mantenha a imagem original inalterada para edições posteriores. Combine a extensão do arquivo com o output_format solicitado e inspecione visualmente textos importantes ou detalhes do produto. Se você mudar de modelo, verifique seu contrato de resposta antes de reutilizar este decodificador base64.

### Editar uma imagem gerada ou local

Faça upload do arquivo de origem como multipart. Declare a mudança solicitada e os detalhes a serem preservados; mantenha o arquivo original e salve cada resultado aprovado com um novo nome.

Para o fluxo separado com a CometAPI, o [endpoint de edição de imagem aceita uploads multipart](https://apidoc.cometapi.com/api/image/openai/image-editing). Salve este script independente como edit_image.py ao lado de product-image.jpeg da etapa de geração e então execute python edit_image.py. O prompt solicita uma única mudança na cor da xícara, e o script salva o 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")


#### Usando uma imagem de referência local

Para editar uma foto de produto existente, defina source para esse arquivo. Defina o MIME type do upload para corresponder ao seu formato real, como image/png para um PNG. O output_format solicitado pode permanecer jpeg independentemente do formato de origem. Deixe requests gerar o cabeçalho multipart Content-Type; forçar manualmente application/json quebraria o upload do arquivo.

Imagens de referência ajudam na consistência, mas não garantem preservação exata de logotipos ou geometria do produto. Mantenha uma etapa de aprovação humana para alegações comerciais sobre o produto.

#### Continuando uma edição

Para outra edição, faça upload da saída aprovada como próxima origem e escreva a próxima instrução. Mantenha cada versão sob um nome de arquivo diferente. Inspecione tanto a mudança solicitada quanto os elementos que devem permanecer inalterados antes de continuar.

## Como enviar e recuperar um vídeo Kling com a CometAPI

### Enviar uma tarefa de vídeo

O guia rápido de texto-para-vídeo do [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) usa uma tarefa assíncrona: envie uma vez, retenha o ID e consulte a rota correspondente. O exemplo abaixo usa `model_name="kling-v3"`, `mode="std"`, `duration="5"` e `sound="off"`. Esses valores se aplicam a esta rota Kling da CometAPI. Descreva uma ação clara do sujeito e o movimento de câmera pretendido.

Use model_name para esta rota específica do provedor e mantenha mode="std", duration="5" e sound="off" para o primeiro teste. Salve o task_id retornado imediatamente. Esta é uma solicitação de texto para vídeo; referências de imagem exigem a rota documentada de imagem para vídeo.

Salve o código como generate_video.py. Execute python generate_video.py para criar uma tarefa. Após uma interrupção no polling, execute python generate_video.py TASK_ID usando o ID salvo para retomar. O [contrato de recuperação de tarefa](https://apidoc.cometapi.com/api/video/kling/individual-queries) documenta a URL do resultado e suporta tanto um envelope data quanto um objeto de tarefa direto.

### Fazer polling da tarefa e baixar o resultado

Uma resposta de criação de vídeo fornece um ID de tarefa, não um arquivo de mídia finalizado. Salve o ID com o job, inspecione task_status ao recuperar e faça download do resultado somente após sucesso. O script completo de vídeo abaixo lida com submissão, polling, falha e download; seu modo de retomada reutiliza o mesmo job.

Recupere a tarefa existente com GET /kling/v1/videos/text2video/{task_id}. Aguarde task_status="succeed" antes de ler task_result.videos[0].url; trate "failed" como erro. Um timeout local de polling deve preservar o ID da tarefa para que a recuperação possa ser retomada sem enviar outra geração.

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


### Conclusão e recuperação

Abra product-video.mp4 e confirme que ele reproduz até o fim. O script salva o resultado da tarefa antes do download, para que uma falha no download não exija gerar outro clipe. Seu deadline local de polling interrompe a espera; ele não cancela a tarefa remota. Mantenha o ID e retome a recuperação. O download do asset usa deliberadamente uma solicitação separada sem autenticação para que a chave da CometAPI não seja enviada ao host de mídia.

O exemplo de vídeo usa entrada de texto. Uma imagem aprovada não pode ser anexada inventando um campo reference_image nessa rota; imagem para vídeo requer o fluxo de trabalho de imagem documentado do provedor selecionado.

## Como estender um fluxo de trabalho da CometAPI para produção?

### Registros de jobs e ativos reutilizáveis

Armazene cada prompt, configuração, asset de origem, ID de tarefa e caminho de saída sob um único job do aplicativo. Mantenha revisões de imagem separadamente para que os usuários possam retornar a uma versão aprovada. Para vídeo, persista o ID da tarefa antes de sair do manipulador de solicitação e permita que um worker gerencie a recuperação.

### Callbacks e reconciliação

Para entrega assíncrona de vídeo, siga as [orientações de polling e webhook da CometAPI](https://apidoc.cometapi.com/guides/webhook-and-polling-for-video-generation). Adicione callbacks somente após o polling básico funcionar e torne seguras de processar as notificações duplicadas. Mantenha um caminho de recuperação para jobs cujo callback atrasar ou falhar.

## Como lidar com erros em um fluxo de trabalho da CometAPI?

Aplique as [orientações documentadas de erro e retry da API](https://apidoc.cometapi.com/guides/error-codes-and-retry-strategy) ao criar este fluxo de trabalho na CometAPI. Primeiro separe uma solicitação inválida de uma falha temporária de transporte. Mantenha status da resposta, identificadores da solicitação e IDs de tarefa nos logs do servidor, enquanto exclui chaves secretas.

* Falha de autenticação: verifique a chave, o acesso da conta e o host de destino antes de tentar novamente.
* Parâmetro não suportado: retorne à menor solicitação documentada e adicione um campo opcional por vez.
* Limite de taxa ou falha transitória no polling: aguarde com backoff limitado e retome a consulta da tarefa existente.
* Timeout na criação: determine se a primeira solicitação criou um job antes de enviar novamente. Repetir uma solicitação de geração pode gerar cobrança adicional.
* Falha no download da saída: use o resultado de tarefa retido ou recupere a tarefa existente novamente em vez de iniciar uma nova geração.

## Conclusão

Escolha primeiro o serviço e a rota de acesso. Para o Kenerate, comece com a configuração oficial de MCP/CLI ou discuta os requisitos de API para Enterprise com o suporte. Para uma implementação separada com a CometAPI, configure sua chave, siga a rota de imagem ou Kling, inspecione as saídas salvas e retenha IDs de tarefa de vídeo para recuperação. Uma primeira meta útil é uma imagem local válida, uma variante editada e um vídeo reproduzível.

## Perguntas frequentes

### Este fluxo de trabalho da CometAPI pode rodar inteiramente no navegador?

Um navegador pode apresentar prompts e progresso, mas um frontend público não deve conter uma chave de API secreta. Coloque as solicitações de geração e o acompanhamento de tarefas por trás do seu próprio backend, autentique o usuário lá e retorne apenas o resultado ou progresso necessário para a interface. Uma implementação separada com a CometAPI deve seguir essa mesma separação.

### O que uma equipe deve solicitar antes da integração Enterprise do Kenerate AI?

Peça a documentação nativa da API e uma descrição por escrito dos modelos e operações disponíveis para sua conta. Resolva também autenticação, cotas, cobrança, retenção de tarefas e responsabilidade de suporte. Uma demonstração no estúdio estabelece uma capacidade criativa, mas não estabelece o esquema de solicitação ou os termos de serviço que seu aplicativo receberá.

### O mesmo prompt do Kenerate AI produzirá uma saída de API idêntica?

Não confie nisso. Primeiro alinhe a versão exata do modelo, os assets de entrada e as configurações de geração expostas. Um estúdio pode adicionar padrões ou processamento que sua solicitação de API não reproduz. Preserve o briefing e os assets de referência aprovados e, em seguida, revise a nova saída em relação aos requisitos reais de entrega, em vez de esperar mídia pixel-idêntica.