En bref : Kenerate AI est un espace de travail créatif qui combine image, vidéo, montage, audio, 3D et des capacités d’agents.

Kenerate AI réunit des outils créatifs dans un seul espace de travail. Les développeurs doivent d’abord distinguer ses options d’accès natives, notamment MCP/CLI et l’accès API Enterprise, d’une intégration CometAPI séparée. Ce guide couvre l’accès et la planification des coûts, la configuration de l’environnement, la génération d’images, la gestion des réponses, l’édition d’images et la création vidéo asynchrone. Suivez les exemples pour enregistrer une image d’origine, une variante éditée et un clip terminé en utilisant Python 3.10+, une clé CometAPI et un solde suffisant.

Points clés

• Kenerate AI est un service créatif multi‑modèles plutôt qu’un unique modèle de base.
• Kenerate propose un accès MCP/CLI ainsi qu’un onboarding API Enterprise ; choisissez la voie qui correspond à votre application et à votre compte.
• Utilisez des IDs de modèle concrets et des paramètres spécifiques à la route lorsque vous construisez une intégration CometAPI séparée.
• Enregistrez les octets d’image après la génération ; conservez un ID de tâche vidéo pour que l’interrogation puisse reprendre sans soumettre un autre job.
• CometAPI propose une intégration développeur séparée pour les modèles image/vidéo pris en charge, avec des identifiants et une facturation distincts.

Qu’est-ce que Kenerate AI ?

Utilisez les studios de Kenerate pour une création interactive. Les développeurs peuvent également utiliser ses outils officiels MCP/CLI ou contacter le support au sujet de l’accès API Enterprise. La section sur l’accès ci‑dessous explique ces options ; les exemples Python plus loin dans ce guide appellent CometAPI séparément.

Kenerate AI et CometAPI sont des services distincts.

Le code ci‑dessous appelle directement CometAPI. Il ne se connecte pas à Kenerate, n’automatise pas un studio Kenerate et ne dépense pas de crédits Kenerate. Il reproduit une tâche créative définie de manière étroite à l’aide d’un modèle pris en charge, sans prétendre à des préréglages ou des résultats de studio identiques.

Exemple officiel d’image produit issu de la galerie Kenerate. Cela illustre un cas d’usage créatif ; ce n’est pas le résultat du code API ci‑dessous.

En quoi la tarification de Kenerate AI affecte‑t‑elle la planification des coûts API ?

Kenerate annonce 25 crédits de départ et des packs de crédits uniques à partir de 15 $. Sa FAQ de facturation indique que les crédits achetés n’expirent pas et que la génération vidéo nécessite un pack de crédits acheté. Ce sont des modalités de facturation des studios, pas un devis pour l’accès API Enterprise.

CometAPI utilise des identifiants et une facturation séparés. Avant un test ou un lot, comparez le modèle sélectionné et les réglages de requête à son estimation des coûts, définissez une limite de job et inspectez l’usage enregistré. Les crédits Kenerate ne déterminent pas le coût des requêtes CometAPI.

Comment accéder à Kenerate AI ?

Se connecter via MCP ou CLI

La page d’installation officielle MCP/CLI de Kenerate fournit une voie native pour les développeurs. Son serveur MCP distant est https://mcp.kenerateai.com/mcp. Ajoutez le serveur dans un client compatible et terminez la connexion à Kenerate lorsque c’est pris en charge ; suivez la page d’installation pour l’installation CLI et l’authentification. Ces outils utilisent votre compte Kenerate, et non une clé CometAPI.

Demander un accès API Enterprise si nécessaire

La FAQ officielle décrit également un accès API pour les partenaires Enterprise via le support. Pour cette voie, demandez la documentation des endpoints, l’authentification, les opérations prises en charge, les quotas et les conditions de facturation. L’onboarding Enterprise ne doit pas être présenté comme la seule option d’intégration native.

Comment configurer un workflow CometAPI distinct ?

Compte et identifiants

Créez un compte CometAPI et générez une clé en suivant les instructions de configuration de clé API. Conservez la clé sur votre serveur ou machine de développement. Les commandes Bash suivantes installent le client HTTP et lisent la clé sans l’afficher. Les utilisateurs Windows peuvent les exécuter dans WSL ou Git Bash.

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

Une première requête petite et spécifique

Utilisez une seule invite et une seule sortie avant d’ajouter des contrôles optionnels. Pour le workflow image, les développeurs peuvent accéder à l’API GPT Image 2 dans CometAPI. Le workflow vidéo utilise l’API Kling Video dans CometAPI avec la valeur model_name spécifique à la route issue de son guide de démarrage développeur. Un libellé de studio n’est pas un substitut à un identifiant d’API.

Comparer les exemples CometAPI

CometAPI documente séparément la requête image et les champs de sortie, ainsi que la soumission vidéo et les routes d’interrogation. Traitez les identifiants, la route, le corps et l’analyse du résultat comme une intégration complète.

Peut‑on utiliser le SDK OpenAI avec CometAPI ?

Oui, pour les routes compatibles avec OpenAI prises en charge. Le guide SDK de CometAPI utilise une clé CometAPI et l’URL de base https://api.cometapi.com/v1. Le SDK OpenAI Python prend en charge un base_url personnalisé. Installez le SDK séparément si vous le choisissez ; les scripts image et vidéo exécutables ci‑dessous utilisent 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",
)

Configuration du client uniquement : aucune requête de génération n’est soumise ici.

La compatibilité s’applique à l’endpoint documenté, aux champs et à la forme de la réponse. Cela ne rend pas chaque route fournisseur interchangeable. Le démarrage rapide image prend en charge client.images.generate ; l’exemple Kling ci‑dessous utilise sa route spécifique fournisseur /kling/v1/videos/text2video et son contrat de tâche. Suivez le démarrage rapide correspondant [image](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) ou [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) plutôt que de substituer un appel vidéo générique du SDK.

## Comment générer et enregistrer une image avec CometAPI ?

### Choisir les paramètres d’image

Pour le premier test d’image, utilisez gpt-image-2, size="1024x1024", quality="low" et output_format="jpeg". Enregistrez le résultat avec une extension de fichier correspondante. Décrivez clairement le produit, l’arrière‑plan et l’éclairage. Cette route image utilise le champ model et renvoie des octets d’image dans data[0].b64_json.

### Générer et enregistrer l’image

CometAPI documente la génération d’images avec [gpt-image-2](https://apidoc.cometapi.com/quickstarts/image/gpt-image-api) et la sortie en base64. Cet exemple envoie une requête synchrone et enregistre les octets renvoyés en JPEG. Enregistrez‑le sous generate_image.py et exécutez python generate_image.py après avoir défini la variable d’environnement.

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": "Une tasse en céramique sur du marbre, éclairage produit réaliste",
"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("Aucun octet d’image renvoyé ; inspectez le schéma de la réponse.")
image_bytes = base64.b64decode(items[0]["b64_json"], validate=True)
if not image_bytes:
raise RuntimeError("L’image renvoyée est vide.")
output = Path("product-image.jpeg")
output.write_bytes(image_bytes)
print(f"Enregistré {output} ({len(image_bytes)} octets)")

### Vérifier l’image enregistrée

Commencez par confirmer que `product-image.jpeg` existe et s’ouvre dans une visionneuse d’images. Vérifiez ensuite si son sujet, sa composition et les détails du produit correspondent à l’invite. Inspectez le sujet et la composition avant de modifier l’invite. Une réponse HTTP 200 confirme que la requête a réussi, mais vous devez toujours valider les données renvoyées et inspecter l’image. Si une réponse contient une erreur ou un schéma différent, inspectez‑la avant de modifier le décodeur ; n’enregistrez pas le texte JSON avec une extension d’image.

Conservez l’image d’origine inchangée pour les modifications ultérieures. Faites correspondre l’extension de fichier au output_format demandé, et inspectez visuellement les textes ou détails produits importants. Si vous changez de modèle, vérifiez son contrat de réponse avant de réutiliser ce décodeur base64.

### Éditer une image générée ou locale

Téléversez le fichier source en tant que données multipart. Énoncez la modification demandée et les détails à préserver ; conservez le fichier original et enregistrez chaque résultat approuvé sous un nouveau nom.

Pour le workflow CometAPI séparé, l’[endpoint d’édition d’images accepte les téléversements multipart](https://apidoc.cometapi.com/api/image/openai/image-editing). Enregistrez ce script autonome sous edit_image.py à côté de product-image.jpeg de l’étape de génération, puis exécutez python edit_image.py. L’invite demande un seul changement de couleur de la tasse, et le script enregistre le résultat sous `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": "Ne changer que la couleur de la tasse en noir mat. Préserver sa forme, l’arrière-plan et l’éclairage.",
"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("Aucune image éditée renvoyée ; inspectez la réponse.")
edited_bytes = base64.b64decode(items[0]["b64_json"], validate=True)
if not edited_bytes:
raise RuntimeError("L’image éditée est vide.")
Path("product-image-edited.jpeg").write_bytes(edited_bytes)
print("Enregistré product-image-edited.jpeg")

#### Utiliser une image de référence locale

Pour modifier une photo de produit existante, définissez source sur ce fichier. Définissez le type MIME de téléversement pour qu’il corresponde à son format réel, tel que image/png pour un PNG. Le output_format demandé peut rester jpeg quel que soit le format source. Laissez requests générer l’en‑tête Content-Type multipart ; forcer manuellement application/json casserait le téléversement de fichier.

Les images de référence aident à la cohérence mais ne garantissent pas la préservation exacte des logos ou de la géométrie du produit. Conservez une étape d’approbation humaine pour les affirmations commerciales sur le produit.

#### Poursuivre une édition

Pour une autre modification, téléversez la sortie approuvée comme prochain source et rédigez la prochaine instruction. Conservez chaque version sous un nom de fichier différent. Inspectez à la fois le changement demandé et les éléments qui doivent rester inchangés avant de continuer.

## Comment soumettre et récupérer une vidéo Kling avec CometAPI

### Soumettre une tâche vidéo

Le démarrage rapide texte‑vers‑vidéo [Kling](https://apidoc.cometapi.com/quickstarts/video/kling-api) utilise une tâche asynchrone : soumettez une fois, conservez l’ID et interrogez la route correspondante. L’exemple ci‑dessous utilise `model_name="kling-v3"`, `mode="std"`, `duration="5"` et `sound="off"`. Ces valeurs s’appliquent à cette route Kling de CometAPI. Décrivez un sujet et une action clairs ainsi que le mouvement de caméra souhaité.

Utilisez model_name pour cette route spécifique au fournisseur, et conservez mode="std", duration="5" et sound="off" pour le premier test. Enregistrez immédiatement le task_id renvoyé. Il s’agit d’une requête texte‑vers‑vidéo ; les références d’image nécessitent la route documentée image‑vers‑vidéo.

Enregistrez le code sous generate_video.py. Exécutez python generate_video.py pour créer une tâche. Après une interruption d’interrogation, exécutez python generate_video.py TASK_ID en utilisant l’ID enregistré pour reprendre. Le [contrat de récupération de tâche](https://apidoc.cometapi.com/api/video/kling/individual-queries) documente l’URL du résultat et prend en charge à la fois une enveloppe data et un objet de tâche direct.

### Interroger la tâche et télécharger le résultat

Une réponse de création vidéo fournit un ID de tâche, pas un fichier média fini. Conservez l’ID avec le job, inspectez task_status lors de la récupération et ne téléchargez le résultat qu’après succès. Le script vidéo complet ci‑dessous gère la soumission, l’interrogation, l’échec et le téléchargement ; son mode reprise réutilise le même job.

Récupérez la tâche existante avec GET /kling/v1/videos/text2video/{task_id}. Attendez task_status="succeed" avant de lire task_result.videos[0].url ; traitez "failed" comme une erreur. Un délai d’attente d’interrogation local doit préserver l’ID de tâche afin que la récupération puisse reprendre sans soumettre une autre génération.

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"Erreur de l’API : {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": "Une montre-bracelet sur du marbre sombre. Mouvement latéral lent de la caméra, lumière douce, sans coupe.",
"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"ID de tâche : {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 "La tâche vidéo a échoué")
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("Enregistré product-video.mp4")
break
time.sleep(5)
else:
raise TimeoutError(f"Interrogation arrêtée. Reprenez avec l’ID de tâche {task_id}.")

### Achèvement et reprise

Ouvrez product-video.mp4 et confirmez qu’il se lit jusqu’au bout. Le script enregistre le résultat de la tâche avant le téléchargement, de sorte qu’un échec de téléchargement ne nécessite pas de générer un autre clip. Sa limite d’attente locale interrompt l’attente ; elle n’annule pas la tâche distante. Conservez l’ID et reprenez la récupération. Le téléchargement de l’asset utilise délibérément une requête séparée non authentifiée afin que la clé CometAPI ne soit pas envoyée à l’hébergeur média.

L’exemple vidéo utilise une entrée texte. Une image approuvée ne peut pas être jointe en inventant un champ reference_image sur cette route ; l’image‑vers‑vidéo nécessite le workflow image du fournisseur sélectionné tel que documenté.

## Comment étendre un workflow CometAPI pour la production ?

### Dossiers de jobs et assets réutilisables

Stockez chaque invite, configuration, asset source, ID de tâche et chemin de sortie sous un même job d’application. Conservez séparément les révisions d’images afin que les utilisateurs puissent revenir à une version approuvée. Pour la vidéo, conservez l’ID de tâche avant de quitter le gestionnaire de requêtes et laissez un worker gérer la récupération.

### Callbacks et rapprochement

Pour la livraison vidéo asynchrone, suivez les [recommandations CometAPI sur l’interrogation et les webhooks](https://apidoc.cometapi.com/guides/webhook-and-polling-for-video-generation). Ajoutez les callbacks seulement après que l’interrogation de base fonctionne, et rendez le traitement des notifications en double inoffensif. Conservez un chemin de récupération pour les jobs dont le callback est retardé ou manqué.

## Comment gérer les erreurs dans un workflow CometAPI ?

Appliquez les [recommandations documentées sur les erreurs API et la stratégie de retry](https://apidoc.cometapi.com/guides/error-codes-and-retry-strategy) lors de la construction de ce workflow CometAPI. Commencez par distinguer une requête invalide d’une défaillance de transport temporaire. Conservez le statut de réponse, les identifiants de requête et les IDs de tâche dans les logs côté serveur, tout en excluant les clés secrètes.

* Échec d’authentification : vérifiez la clé, l’accès au compte et l’hôte de destination avant de réessayer.
* Paramètre non pris en charge : revenez à la plus petite requête documentée, puis ajoutez un champ optionnel à la fois.
* Limite de débit ou échec temporaire d’interrogation : attendez avec un backoff borné et reprenez la requête de la tâche existante.
* Délai dépassé à la création : déterminez si la première requête a créé un job avant de soumettre à nouveau. Répéter une requête de génération peut entraîner un coût supplémentaire.
* Échec de téléchargement de la sortie : utilisez le résultat de tâche conservé ou récupérez à nouveau la tâche existante au lieu de démarrer une nouvelle génération.

## Conclusion

Choisissez d’abord le service et la voie d’accès. Pour Kenerate, commencez par l’installation officielle MCP/CLI ou discutez des exigences d’API Enterprise avec le support. Pour une implémentation CometAPI séparée, configurez sa clé, suivez la route image ou Kling, inspectez les sorties enregistrées et conservez les IDs de tâche vidéo pour la reprise. Un premier jalon utile est une image locale valide, une variante éditée et une vidéo lisible.

## FAQ

### Ce workflow CometAPI peut‑il s’exécuter entièrement dans un navigateur ?

Un navigateur peut présenter des invites et l’avancement, mais un frontend public ne doit pas contenir de clé API secrète. Placez les requêtes de génération et le suivi des tâches derrière votre propre backend, authentifiez l’utilisateur là‑bas et ne retournez à l’interface que le résultat ou l’avancement nécessaires. Une implémentation CometAPI séparée doit suivre la même séparation.

### Que devrait demander une équipe avant l’onboarding Enterprise de Kenerate AI ?

Demandez la documentation API native et une description écrite des modèles et opérations disponibles pour votre compte. Résolvez également l’authentification, les quotas, la facturation, la rétention des tâches et la responsabilité du support. Une démonstration en studio établit une capacité créative, mais n’établit pas le schéma de requête ni les conditions de service que votre application recevra.

### La même invite Kenerate AI produira‑t‑elle une sortie API identique ?

N’y comptez pas. Alignez d’abord la version exacte du modèle, les assets d’entrée et les réglages de génération exposés. Un studio peut ajouter des valeurs par défaut ou un traitement que votre requête API ne reproduit pas. Préservez le brief et les assets de référence approuvés, puis comparez la nouvelle sortie aux exigences réelles de livraison au lieu d’attendre des médias pixel‑identiques.