TL;DR: Kenerate AI è uno spazio di lavoro creativo che combina funzionalità di immagine, video, editing, audio, 3D e agent.

Kenerate AI riunisce strumenti creativi in un unico workspace. Gli sviluppatori dovrebbero innanzitutto distinguere le opzioni di accesso nativo, tra cui MCP/CLI e accesso API Enterprise, da un’integrazione separata con CometAPI. Questa guida tratta pianificazione di accesso e costi, configurazione dell’ambiente, generazione di immagini, gestione delle risposte, editing di immagini e creazione asincrona di video. Segui gli esempi per salvare un’immagine originale, una variante modificata e una clip completata usando Python 3.10+, una chiave CometAPI e saldo sufficiente.

Punti chiave

• Kenerate AI è un servizio creativo multi‑modello, non un singolo foundation model.
• Kenerate offre accesso MCP/CLI e onboarding API Enterprise; scegli il percorso che corrisponde alla tua applicazione e al tuo account.
• Usa ID di modello concreti e parametri specifici della route quando crei un’integrazione separata con CometAPI.
• Salva i byte dell’immagine dopo la generazione; conserva l’ID del task video così il polling può riprendere senza inviare un altro job.
• CometAPI offre un’integrazione sviluppatore separata per modelli immagine/video supportati, con credenziali e fatturazione separati.

Che cos’è Kenerate AI?

Usa gli studi di Kenerate per la creazione interattiva. Gli sviluppatori possono anche usare i suoi strumenti ufficiali MCP/CLI o contattare il supporto per l’accesso API Enterprise. La sezione sull’accesso qui sotto spiega queste opzioni; gli esempi Python più avanti in questa guida chiamano separatamente CometAPI.

Kenerate AI e CometAPI sono servizi separati.

Il codice seguente chiama direttamente CometAPI. Non effettua l’accesso a Kenerate, non automatizza uno studio di Kenerate e non spende crediti Kenerate. Ricrea un’attività creativa definita in modo ristretto usando un modello supportato, senza pretendere preset o output identici agli studi.

Esempio ufficiale di immagine di prodotto dalla galleria Kenerate. Illustra un caso d’uso creativo; non è l’output del codice API sottostante.

In che modo i prezzi di Kenerate AI incidono sulla pianificazione dei costi API?

Kenerate pubblicizza 25 crediti iniziali e pacchetti di crediti una tantum a partire da $15. Le sue FAQ di fatturazione indicano che i crediti acquistati non scadono e che la generazione video richiede un pacchetto crediti acquistato. Questi sono termini di fatturazione dello studio, non un preventivo per l’accesso API Enterprise.

CometAPI usa credenziali e fatturazione separati. Prima di un test o di un batch, verifica il modello selezionato e le impostazioni della richiesta rispetto alla sua stima dei costi, imposta un limite di job e ispeziona l’utilizzo registrato. I crediti Kenerate non determinano il costo delle richieste CometAPI.

Come accedere a Kenerate AI?

Connessione tramite MCP o CLI

La pagina ufficiale di setup MCP/CLI di Kenerate fornisce un percorso nativo per gli sviluppatori. Il suo server MCP remoto è https://mcp.kenerateai.com/mcp. Aggiungi il server in un client compatibile e completa l’accesso a Kenerate dove supportato; segui la pagina di setup per l’installazione e l’autenticazione via CLI. Questi strumenti usano il tuo account Kenerate, non una chiave CometAPI.

Richiedi l’accesso API Enterprise quando necessario

Le FAQ ufficiali descrivono anche l’accesso API per partner Enterprise tramite supporto. Per quel percorso, richiedi documentazione degli endpoint, autenticazione, operazioni supportate, quote e termini di fatturazione. L’onboarding Enterprise non dovrebbe essere presentato come l’unica opzione di integrazione nativa.

Come configurare un workflow separato con CometAPI?

Account e credenziali

Crea un account CometAPI e genera una chiave seguendo le istruzioni di setup della chiave API. Conserva la chiave sul tuo server o sulla macchina di sviluppo. I seguenti comandi Bash installano il client HTTP e leggono la chiave senza visualizzarla. Gli utenti Windows possono eseguirli in WSL o Git Bash.

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

Una prima richiesta piccola e specifica

Usa un solo prompt e un solo output prima di aggiungere controlli opzionali. Per il workflow immagine, gli sviluppatori possono accedere alla GPT Image 2 API in CometAPI. Il workflow video usa la Kling Video API in CometAPI con il valore model_name specifico della route dal suo quickstart per sviluppatori. Un’etichetta dello studio non sostituisce un identificatore API.

Confronta gli esempi CometAPI

CometAPI documenta separatamente i campi della richiesta e dell’output per le immagini e le route di invio/polling per i video. Considera credenziali, route, body e parsing dei risultati come un’integrazione completa.

Puoi usare l’SDK OpenAI con CometAPI?

Sì, per le route compatibili con OpenAI supportate. La guida all’SDK di CometAPI usa una chiave CometAPI e la base URL https://api.cometapi.com/v1. L’OpenAI Python SDK supporta una base_url personalizzata. Installa l’SDK separatamente se lo scegli; gli script eseguibili per immagini e video sotto usano 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 compatibilità si applica all’endpoint documentato, ai campi e alla forma della risposta. Non rende intercambiabile ogni route del provider. L’avvio rapido per le immagini supporta client.images.generate; l’esempio Kling qui sotto usa la route specifica del provider /kling/v1/videos/text2video e il relativo contratto di task. Segui l’avvio rapido corrispondente per le [immagini](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) o per [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) invece di sostituire una chiamata video generica dell’SDK.

## Come generare e salvare un’immagine con CometAPI?

### Scegli le impostazioni immagine

Per il primo test immagine, usa gpt-image-2, size="1024x1024", quality="low" e output_format="jpeg". Salva il risultato con un’estensione file corrispondente. Descrivi chiaramente prodotto, sfondo e illuminazione. Questa route immagine usa il campo model e restituisce i byte dell’immagine in data[0].b64_json.

### Genera e salva l’immagine

CometAPI documenta la generazione di immagini con [gpt-image-2](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) e output in base64. Questo esempio invia una richiesta sincrona e salva i byte restituiti come JPEG. Salvalo come generate_image.py ed esegui python generate_image.py dopo aver impostato la variabile d’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)")

### Verifica l’immagine salvata

Per prima cosa conferma che `product-image.jpeg` esista e si apra in un visualizzatore di immagini. Poi verifica se soggetto, composizione e dettagli di prodotto corrispondono al prompt. Ispeziona soggetto e composizione prima di modificare il prompt. Una risposta HTTP 200 conferma che la richiesta è riuscita, ma devi comunque convalidare i dati restituiti e ispezionare l’immagine. Se una risposta contiene un errore o uno schema diverso, ispezionala prima di cambiare il decoder; non salvare il testo JSON con un’estensione immagine.

Mantieni l’immagine originale invariata per gli editing successivi. Abbina l’estensione del file all’output_format richiesto e ispeziona visivamente testo importante o dettagli del prodotto. Se cambi modello, verifica il suo contratto di risposta prima di riutilizzare questo decoder base64.

### Modifica un’immagine generata o locale

Carica il file sorgente come multipart. Indica la modifica richiesta e i dettagli da preservare; mantieni il file originale e salva ogni risultato approvato con un nuovo nome.

Per il workflow separato con CometAPI, l’[endpoint di image-edit accetta upload multipart](https://apidoc.cometapi.com/api/image/openai/image-editing). Salva questo script autonomo come edit_image.py accanto a product-image.jpeg dello step di generazione, quindi esegui python edit_image.py. Il prompt richiede un’unica modifica al colore della tazza e lo script salva il risultato come `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 di un’immagine di riferimento locale

Per modificare una foto di prodotto esistente, imposta source su quel file. Imposta il tipo MIME di upload in base al suo formato effettivo, ad esempio image/png per un PNG. L’output_format richiesto può restare jpeg indipendentemente dal formato sorgente. Lascia che requests generi l’header Content-Type multipart; forzare manualmente application/json interromperebbe l’upload del file.

Le immagini di riferimento aiutano con la coerenza ma non garantiscono la conservazione esatta di loghi o geometrie di prodotto. Mantieni un passaggio di approvazione umana per le affermazioni commerciali sul prodotto.

#### Proseguire una modifica

Per un’altra modifica, carica l’output approvato come nuovo sorgente e scrivi la successiva istruzione. Mantieni ogni versione con un nome file diverso. Prima di continuare, ispeziona sia la modifica richiesta sia gli elementi che dovrebbero restare invariati.

## Come inviare e recuperare un video Kling con CometAPI

### Invia un task video

Il quickstart [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) text‑to‑video usa un task asincrono: invia una sola volta, conserva l’ID e interroga la route corrispondente. L’esempio seguente usa `model_name="kling-v3"`, `mode="std"`, `duration="5"` e `sound="off"`. Questi valori si applicano a questa route Kling di CometAPI. Descrivi un’azione chiara di un solo soggetto e il movimento di camera previsto.

Usa model_name per questa route specifica del provider e mantieni mode="std", duration="5" e sound="off" per il primo test. Salva immediatamente il task_id restituito. Questa è una richiesta text‑to‑video; le immagini di riferimento richiedono la route documentata image‑to‑video.

Salva il codice come generate_video.py. Esegui python generate_video.py per creare un task. Dopo un’interruzione del polling, esegui python generate_video.py TASK_ID usando l’ID salvato per riprendere. Il [contratto di recupero del task](https://apidoc.cometapi.com/api/video/kling/individual-queries) documenta l’URL del risultato e supporta sia una busta dati sia un oggetto task diretto.

### Esegui il polling del task e scarica il risultato

La risposta di creazione di un video fornisce un ID di task, non un file multimediale finito. Salva l’ID con il job, ispeziona task_status al recupero e scarica il risultato solo dopo il successo. Lo script video completo seguente gestisce invio, polling, errore e download; la modalità di ripresa riutilizza lo stesso job.

Recupera il task esistente con GET /kling/v1/videos/text2video/{task_id}. Attendi task_status="succeed" prima di leggere task_result.videos[0].url; gestisci "failed" come errore. Un timeout di polling locale dovrebbe preservare l’ID del task così il recupero può riprendere senza inviare un’altra generazione.

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

### Completamento e ripristino

Apri product-video.mp4 e conferma che venga riprodotto per intero. Lo script salva il risultato del task prima del download, così un errore nel download non richiede la generazione di un’altra clip. Il suo timeout di polling locale interrompe l’attesa; non annulla il task remoto. Conserva l’ID e riprendi il recupero. Il download dell’asset usa deliberatamente una richiesta separata non autenticata in modo che la chiave CometAPI non venga inviata all’host dei media.

L’esempio video usa input testuale. Un’immagine approvata non può essere allegata inventando un campo reference_image su questa route; l’immagine‑in‑video richiede il workflow per immagini documentato dal provider selezionato.

## Come estendere un workflow CometAPI per la produzione?

### Record dei job e asset riutilizzabili

Archivia ogni prompt, configurazione, asset sorgente, ID del task e percorso di output sotto un singolo job dell’applicazione. Tieni separatamente le revisioni delle immagini così gli utenti possono tornare a una versione approvata. Per i video, conserva l’ID del task prima di lasciare l’handler della richiesta e lascia che un worker gestisca il recupero.

### Callback e riconciliazione

Per la consegna asincrona dei video, segui le [indicazioni di CometAPI su polling e webhook](https://apidoc.cometapi.com/guides/webhook-and-polling-for-video-generation). Aggiungi i callback solo dopo che il polling di base funziona e rendi sicura l’elaborazione di notifiche duplicate. Mantieni un percorso di recupero per i job il cui callback è in ritardo o mancato.

## Come gestire gli errori in un workflow CometAPI?

Applica le [linee guida documentate per errori API e retry](https://apidoc.cometapi.com/guides/error-codes-and-retry-strategy) quando costruisci questo workflow CometAPI. Innanzitutto separa una richiesta non valida da un errore di trasporto temporaneo. Conserva stato della risposta, identificatori della richiesta e ID dei task nei log lato server, escludendo le chiavi segrete.

* Errore di autenticazione: verifica chiave, accesso all’account e host di destinazione prima di riprovare.
* Parametro non supportato: torna alla richiesta minima documentata, quindi aggiungi un campo opzionale alla volta.
* Limitazione di velocità o errore di polling temporaneo: attendi con backoff con limiti e riprendi la query del task esistente.
* Timeout di creazione: determina se la prima richiesta ha creato un job prima di inviarne un’altra. Ripetere una richiesta di generazione può comportare un costo aggiuntivo.
* Download dell’output non riuscito: usa il risultato del task conservato o recupera di nuovo il task esistente invece di avviare una nuova generazione.

## Conclusione

Scegli prima il servizio e il percorso di accesso. Per Kenerate, inizia con il setup ufficiale MCP/CLI o discuti i requisiti API Enterprise con il supporto. Per un’implementazione separata con CometAPI, configura la sua chiave, segui la route per immagini o Kling, ispeziona gli output salvati e conserva gli ID dei task video per il ripristino. Un traguardo utile è una valida immagine locale, una variante modificata e un video riproducibile.

## FAQ

### Questo workflow CometAPI può essere eseguito interamente in un browser?

Un browser può presentare prompt e avanzamento, ma un frontend pubblico non dovrebbe contenere una chiave API segreta. Metti le richieste di generazione e il tracking dei task dietro il tuo backend, autentica lì l’utente e restituisci solo il risultato o l’avanzamento necessario all’interfaccia. Un’implementazione separata con CometAPI dovrebbe seguire la stessa separazione.

### Cosa dovrebbe richiedere un team prima dell’onboarding Enterprise di Kenerate AI?

Richiedi la documentazione API nativa e una descrizione scritta dei modelli e delle operazioni disponibili per il tuo account. Risolvi anche autenticazione, quote, fatturazione, conservazione dei task e proprietà del supporto. Una dimostrazione dello studio stabilisce una capacità creativa, ma non stabilisce lo schema di richiesta o i termini del servizio che riceverà la tua applicazione.

### Lo stesso prompt in Kenerate AI produrrà un output API identico?

Non farci affidamento. Prima allinea l’esatta versione del modello, gli asset di input e le impostazioni di generazione esposte. Uno studio può aggiungere predefiniti o elaborazioni che la tua richiesta API non riproduce. Conserva il brief e gli asset di riferimento approvati, quindi valuta il nuovo output rispetto ai requisiti effettivi di consegna invece di aspettarti media identici pixel‑per‑pixel.