Tâches asynchrones

AIHubMix propose trois groupes d’API de tâches : /ai/v1/images pour les images, /ai/v1/videos pour les vidéos et /ai/v1/tasks pour les enregistrements de tâches unifiés.

La génération d’images est synchrone par défaut et devient asynchrone avec async: true.
La génération vidéo est toujours asynchrone.
Les API de détail des images et des vidéos fournissent le dernier statut des tâches média.
/ai/v1/tasks fournit une vue unifiée en lecture seule des tâches d’image, de vidéo et de LLM.

Si une vidéo Doubao Seedance doit référencer des ressources de personnes réelles, suivez d’abord le guide des ressources de personnes réelles pour Doubao pour effectuer la confirmation personnelle et préparer les ressources, puis créez la tâche vidéo.

Tutoriel vidéo : tâches asynchrones

Présente le fonctionnement global des tâches asynchrones et illustre le flux d’appel complet avec une génération d’image asynchrone.

Activer les tâches asynchrones dans la console

Avant d’utiliser les API de tâches média /ai/v1, activez les tâches asynchrones pour le compte courant.

Si les tâches asynchrones ne sont pas activées, les requêtes de création d’image et de vidéo renvoient 403 async_not_enabled.

Démarrage rapide

L’exemple suivant crée une vidéo avec wan2.6-t2v. Ce modèle accepte duration et size. Les champs valides peuvent varier selon le modèle.

# 1. Créer la tâche vidéo et conserver l'id de la réponse
curl -X POST https://aihubmix.com/ai/v1/videos \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan2.6-t2v",
    "prompt": "A cat playing jazz on a piano, warm lighting, cinematic shot",
    "duration": 5,
    "size": "1280x720"
  }'

# 2. Consulter le détail média toutes les 15 secondes
curl https://aihubmix.com/ai/v1/videos/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

# 3. Télécharger la vidéo lorsque le statut est completed
curl https://aihubmix.com/ai/v1/videos/{task_id}/content \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output result.mp4

{
  "id": "task_01K0ABCDEF",
  "object": "video",
  "model": "wan2.6-t2v",
  "status": "in_progress",
  "output": [],
  "error": null,
  "created_at": 1784707200,
  "completed_at": null,
  "expires_at": null
}

Comment choisir entre les trois groupes d’API ?

Cas d’utilisation	Méthode	Chemin	Comportement
Générer une image	POST	`/ai/v1/images/generations`	Synchrone par défaut, asynchrone avec `async: true`
Consulter une image	GET	`/ai/v1/images/{id}`	Renvoie le statut, qui peut être actualisé lors de la consultation pour une tâche active
Lister les images	GET	`/ai/v1/images`	Renvoie un instantané des tâches d’image
Télécharger une image précise	GET	`/ai/v1/images/{id}/content/{result_id}`	Télécharge un résultat précis d’une tâche à plusieurs images
Créer une vidéo	POST	`/ai/v1/videos`	Toujours asynchrone
Consulter une vidéo	GET	`/ai/v1/videos/{id}`	Renvoie le statut, qui peut être actualisé lors de la consultation pour une tâche active
Lister les vidéos	GET	`/ai/v1/videos`	Renvoie un instantané des tâches vidéo
Télécharger une vidéo	GET	`/ai/v1/videos/{id}/content`	Télécharge le résultat vidéo principal
Lister les modèles média asynchrones	GET	`/api/v1/models?type={type}&schema_checked=true`	Renvoie les modèles texte-image ou texte-vidéo disposant d’un schéma de requête
Obtenir le schéma de requête d’un modèle	GET	`/call/schema/models/{model}/endpoints`	Renvoie les endpoints texte-image ou texte-vidéo et leurs schémas JSON
Lister les tâches unifiées	GET	`/ai/v1/tasks`	Consultation en lecture seule des tâches d’image, de vidéo et de LLM
Consulter une tâche unifiée	GET	`/ai/v1/tasks/{id}`	Renvoie un instantané en lecture seule au moment de la consultation
Récupérer le résultat d’une tâche unifiée	GET	`/ai/v1/tasks/{id}/content`	Télécharge un résultat unique ou lit une archive LLM
Récupérer un résultat unifié précis	GET	`/ai/v1/tasks/{id}/content/{result_id}`	Télécharge un résultat précis d’une tâche à plusieurs résultats

La Base URL est https://aihubmix.com. L’authentification utilise un Bearer Token :

Authorization: Bearer $AIHUBMIX_API_KEY

Les endpoints de liste des modèles et de schéma des modèles sont publics et ne nécessitent pas de Bearer Token. Tous les autres endpoints nécessitent une authentification.

/ai/v1/tasks ne propose pas d’API de création. Les images et vidéos doivent être créées avec leur API média respective. Les tâches de reprise LLM sont enregistrées automatiquement par la plateforme après une interruption du client.

Différences entre les API média et l’API de tâches unifiées

Les API de détail média et de tâches unifiées renvoient les mêmes champs de premier niveau, mais leurs éléments output et leur comportement de consultation diffèrent.

Élément comparé	Détail média `/images/{id}`, `/videos/{id}`	Détail unifié `/tasks/{id}`
Type de tâche	Image ou vidéo	Image, vidéo ou LLM
Consultation	Le statut d’une tâche active peut être actualisé	Renvoie un instantané en lecture seule au moment de la consultation
Champs de sortie média	`index`, `type`, `content_url`, `b64_json`	`index`, `result_id`, `type`, `content_type`, `content_url`
Champs de sortie LLM	Sans objet	`index`, `type=response`, `content_type`, `content_url`, `truncated`
Périmètre d’accès	Tâches média correspondantes créées par le compte courant	Tâches créées avec le Bearer Token courant

Utilisez donc l’API de détail d’image ou de vidéo pour suivre le statut d’une génération média. Utilisez /ai/v1/tasks pour filtrer toutes les tâches, lire les métadonnées des résultats ou récupérer une réponse LLM.

Comment découvrir les modèles média asynchrones et obtenir leurs schémas ?

La découverte se déroule en deux étapes. Récupérez d’abord dans le catalogue public les modèles texte-image ou texte-vidéo compatibles avec les API asynchrones. Utilisez ensuite le model_id du modèle pour obtenir le schéma de requête de ses endpoints.

Lister les modèles compatibles avec les API asynchrones

Le catalogue de modèles utilise la même source de données que Playground. Utilisez type=image_generation pour les modèles texte-image et type=video pour les modèles texte-vidéo. Le paramètre schema_checked=true limite la liste aux modèles dont le schéma de requête a été publié et vérifié.

# Modèles texte-image
curl "https://aihubmix.com/api/v1/models?type=image_generation&schema_checked=true&sort_by=order"

# Modèles texte-vidéo
curl "https://aihubmix.com/api/v1/models?type=video&schema_checked=true&sort_by=order"

Les deux requêtes utilisent le même endpoint. Le filtre type accepte actuellement une seule valeur. Interrogez donc chaque type de modèle séparément. La réponse suit la forme {success, message, data}. Les champs de data utiles aux intégrations média asynchrones sont les suivants.

Champ	Description
`data[].model_id`	ID du modèle utilisé pour la génération et les requêtes de schéma suivantes
`data[].model_name`	Nom d’affichage du modèle
`data[].types`	Types séparés par des virgules, avec éventuellement `image_generation` et `llm`
`data[].input_modalities`	Modalités d’entrée séparées par des virgules
`data[].schema_checked`	`true` lorsque le schéma de requête a été publié et vérifié

{
  "success": true,
  "message": "",
  "data": [
    {
      "model_id": "qwen-image-2.0",
      "model_name": "Qwen Image 2.0",
      "types": "image_generation",
      "input_modalities": "text,image",
      "schema_checked": true
    }
  ]
}

Obtenir le schéma de requête d’un modèle

Les champs, les valeurs d’énumération et les plages numériques pris en charge peuvent varier selon le modèle. Avant d’envoyer une requête d’image ou de vidéo, utilisez l’endpoint public ci-dessous pour récupérer les endpoints disponibles et les schémas JSON de requête du modèle sélectionné.

# Modèle texte-image
curl "https://aihubmix.com/call/schema/models/qwen-image-2.0/endpoints"

# Modèle texte-vidéo
curl "https://aihubmix.com/call/schema/models/wan2.6-t2v/endpoints"

La valeur modality de la réponse est image ou video. Chaque élément du tableau endpoints décrit un protocole d’appel disponible.

Champ	Description
`default_endpoint`	Identifiant de l’endpoint par défaut du modèle
`endpoints[].endpoint`	Identifiant de l’endpoint
`endpoints[].method`	Méthode HTTP, par exemple `POST`
`endpoints[].path`	Chemin de la requête
`endpoints[].content_types`	Types de contenu acceptés par l’endpoint
`endpoints[].lifecycle`	Mode synchrone ou asynchrone, chemin d’interrogation et valeurs de statut
`endpoints[].request.schema`	Schéma JSON complet de la requête pour ce modèle et cet endpoint, avec les champs requis et les contraintes de valeurs

Un modèle peut renvoyer des endpoints /ai/v1 ainsi que des endpoints /v1 compatibles avec OpenAI. Les endpoints compatibles avec OpenAI peuvent ne pas encore prendre en charge les modèles les plus récents. Utilisez donc de préférence les endpoints /ai/v1. Pour les API de tâches asynchrones, sélectionnez l’élément dont le path est /ai/v1/images/generations ou /ai/v1/videos, puis utilisez son request.schema. Ne dépendez pas de la position d’un élément dans le tableau endpoints. Les commandes suivantes extraient directement le schéma de requête de chaque endpoint de tâche asynchrone.

# Texte-image
curl -s "https://aihubmix.com/call/schema/models/qwen-image-2.0/endpoints" \
  | jq '.endpoints[] | select(.path == "/ai/v1/images/generations") | .request.schema'

# Texte-vidéo
curl -s "https://aihubmix.com/call/schema/models/wan2.6-t2v/endpoints" \
  | jq '.endpoints[] | select(.path == "/ai/v1/videos") | .request.schema'

L’endpoint renvoie 404 model_not_found si le modèle n’existe pas ou ne dispose d’aucun endpoint détectable. Il renvoie 500 endpoints_unavailable lorsque les données des endpoints sont temporairement indisponibles.

Modèles et champs pris en charge

Les protocoles d’image et de vidéo définissent des champs standard communs aux modèles. Chaque modèle limite toutefois les champs, les valeurs d’énumération et les plages numériques selon ses capacités. Avant l’appel, récupérez les contraintes actuelles du modèle depuis l’endpoint de schéma du modèle. Par exemple :

wan2.6-t2v accepte duration, size et seed, mais pas resolution, aspect_ratio, frame_images, input_references ni generate_audio.
qwen-image-2.0 accepte n, size, seed, negative_prompt, image et images, mais pas aspect_ratio ni mask.

L’ensemble des champs standard ne signifie pas que tous les modèles acceptent chaque champ. Un champ non pris en charge par le modèle courant renvoie une erreur de paramètre.

Modèles de reprise après interruption LLM

Les modèles suivants sont actuellement pris en charge :

gpt-5.6-sol
gpt-5.5-pro
gpt-5.4-pro
gpt-5.2-pro
claude-fable-5
claude-opus-5

Le périmètre peut évoluer. Consultez la liste de cette page. La reprise nécessite également l’activation des tâches asynchrones pour le compte courant. Si l’une de ces conditions n’est pas remplie, la requête LLM d’origine s’exécute normalement, mais aucune tâche de reprise n’est enregistrée après la déconnexion du client.

Comment créer une tâche d’image ?

Image synchrone

Lorsque async est omis ou vaut false, l’API attend la fin de la génération et renvoie l’objet tâche :

curl -X POST https://aihubmix.com/ai/v1/images/generations \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-2.0",
    "prompt": "A flower shop with delicate windows, warm sunlight streaming in",
    "n": 1,
    "size": "1024x1024",
    "response_format": "url"
  }'

Les tâches d’image synchrones sont également enregistrées. Si la connexion du client est interrompue ou si la réponse de création est perdue, utilisez GET /ai/v1/images pour retrouver la tâche.

Image asynchrone

Lorsque async vaut le booléen true, l’API renvoie immédiatement l’objet tâche et la génération se poursuit en arrière-plan :

curl -X POST https://aihubmix.com/ai/v1/images/generations \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-2.0",
    "prompt": "A flower shop with delicate windows, warm sunlight streaming in",
    "n": 2,
    "size": "1024x1024",
    "async": true
  }'

Consultez la tâche avec GET /ai/v1/images/{id}. Une fois terminée, demandez directement le content_url de chaque élément output. Cette URL contient le result_id de l’image correspondante.

Dans une requête d’image, async doit être un booléen. webhook_url et webhook_events_filter ne peuvent être utilisés qu’avec async: true.

Champs standard des images

Champ	Type	Obligatoire	Description
`model`	string	Oui	Nom du modèle
`prompt`	string	Oui	Description de l’image, non vide
`n`	integer/null	Non	Nombre d’images, minimum `1`, valeur par défaut `1`
`size`	string/null	Non	`{width}x{height}`, par exemple `1024x1024`
`aspect_ratio`	string/null	Non	Rapport largeur-hauteur, mutuellement exclusif avec `size`
`seed`	integer/null	Non	Graine aléatoire
`negative_prompt`	string/null	Non	Prompt négatif
`image`	string/object	Non	Image d’entrée unique sous forme d’URL, de Data URI, de Base64 ou d’objet `{url}`
`images`	array/null	Non	Plusieurs images d’entrée
`mask`	string/object	Non	Masque de modification d’image
`output_format`	string/null	Non	`png`, `jpeg` ou `webp`, valeur par défaut `png`
`response_format`	string/null	Non	`url` ou `b64_json`, valeur par défaut `url`
`async`	boolean	Non	Exécution asynchrone si la valeur est `true`
`webhook_url`	string	Non	Adresse de rappel HTTPS, 512 caractères maximum
`webhook_events_filter`	string[]	Non	Sous-ensemble non vide de `completed`, `failed`, `cancelled`
`extra`	object/null	Non	Paramètres étendus propres au modèle

Comment créer une tâche vidéo ?

Les requêtes vidéo sont toujours asynchrones et Prefer: wait ne permet pas d’attendre en mode synchrone. Le protocole standard utilise l’entier duration exprimé en secondes :

curl -X POST https://aihubmix.com/ai/v1/videos \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan2.6-t2v",
    "prompt": "Ocean waves crashing on rocky cliffs at sunset",
    "duration": 5,
    "size": "1280x720"
  }'

Champs standard des vidéos

Champ	Type	Obligatoire	Description
`model`	string	Oui	Nom du modèle
`prompt`	string	Oui	Description de la vidéo, non vide
`duration`	integer/null	Non	Durée en secondes, plage définie par le modèle
`aspect_ratio`	string/null	Non	Rapport largeur-hauteur, valeur par défaut du protocole `16:9`
`resolution`	string/null	Non	`480p`, `720p`, `1080p`, `1K`, `2K` ou `4K`
`size`	string/null	Non	`{width}x{height}`, peut remplacer `resolution` et `aspect_ratio`
`seed`	integer/null	Non	Graine aléatoire
`input_references`	array/null	Non	Ressources de référence sous forme d’image, de vidéo ou d’audio
`frame_images`	array/null	Non	Image de première ou de dernière frame
`generate_audio`	boolean/null	Non	Indique si une piste audio doit être générée
`webhook_url`	string	Non	Adresse de rappel HTTPS, 512 caractères maximum
`webhook_events_filter`	string[]	Non	Sous-ensemble non vide de `completed`, `failed`, `cancelled`
`extra`	object/null	Non	Paramètres étendus propres au modèle

Structure d’un élément input_references :

{
  "type": "image_url",
  "url": "https://example.com/reference.png"
}

type peut valoir image_url, video_url ou audio_url. Structure d’un élément frame_images :

{
  "frame_type": "first_frame",
  "image_url": {
    "url": "https://example.com/first-frame.png"
  }
}

frame_type peut valoir first_frame ou last_frame.

Objet de tâche média

Les API propres aux images et aux vidéos renvoient la structure suivante :

{
  "id": "task_01K0ABCDEF",
  "object": "video",
  "model": "wan2.6-t2v",
  "status": "completed",
  "output": [
    {
      "index": 0,
      "type": "file",
      "b64_json": null,
      "content_url": "https://aihubmix.com/ai/v1/videos/task_01K0ABCDEF/content"
    }
  ],
  "error": null,
  "created_at": 1784707200,
  "completed_at": 1784707320,
  "expires_at": null
}

Champ	Type	Description
`id`	string	ID de tâche de la plateforme
`object`	string	`image` ou `video`
`model`	string	Nom du modèle
`status`	string	Statut actuel de la tâche
`output`	array	Résultats générés, tableau vide s’il n’y en a pas encore
`error`	object/null	Informations d’échec, pouvant contenir `code`, `message` et `upstream_detail`
`created_at`	integer	Date de création, en secondes Unix
`completed_at`	integer/null	Date du statut final, en secondes Unix
`expires_at`	null	Les API propres aux médias renvoient actuellement `null`

Élément output d’un média :

Champ	Type	Description
`index`	integer	Ordre du résultat, à partir de `0`
`type`	string	Vaut actuellement `file`
`content_url`	string/null	Adresse de téléchargement du résultat
`b64_json`	string/null	Résultat d’image encodé en Base64

Description des statuts

Statut	Terminé	Description
`pending`	Non	La plateforme a reçu la tâche, en attente d’exécution
`in_progress`	Non	La tâche est en cours d’exécution
`completed`	Oui	La tâche est terminée, `output` est disponible
`failed`	Oui	La tâche a échoué, consulter `error`
`cancelled`	Oui	La tâche a été annulée

Le client peut interroger la tâche toutes les 15 secondes jusqu’au statut completed, failed ou cancelled. Cet intervalle de 15 secondes est une recommandation pour le polling côté client, pas une restriction du protocole serveur.

Comment consulter les tâches média ?

Consulter le détail d’un média

# Image
curl https://aihubmix.com/ai/v1/images/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

# Vidéo
curl https://aihubmix.com/ai/v1/videos/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

Les API de détail média peuvent renvoyer un statut actualisé. Utilisez donc l’API de détail d’image ou de vidéo correspondante pour le polling.

Lister les médias

Si la réponse de création est perdue, retrouvez l’ID de tâche dans la liste du média correspondant :

curl "https://aihubmix.com/ai/v1/videos?limit=20&order=desc" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

Paramètre	Type	Valeur par défaut	Description
`after`	string	-	Curseur de pagination, utiliser le `next_after` de la page précédente
`limit`	integer	`20`	Nombre d’éléments par page, maximum `100`
`order`	string	`desc`	Ordre croissant avec `asc`, toute autre valeur est traitée comme `desc`

{
  "object": "list",
  "data": [
    {
      "id": "task_01K0ABCDEF",
      "object": "video",
      "model": "wan2.6-t2v",
      "status": "in_progress",
      "output": [],
      "error": null,
      "created_at": 1784707200,
      "completed_at": null,
      "expires_at": null
    }
  ],
  "has_more": true,
  "next_after": "task_01K0ABCDEF"
}

La liste média renvoie un instantané au moment de la consultation et n’actualise pas activement le statut des tâches.

Comment utiliser l’API de tâches unifiées ?

L’API de tâches unifiées accepte les filtres suivants :

curl "https://aihubmix.com/ai/v1/tasks?object=video&status=in_progress&limit=20&order=desc" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

Paramètre	Type	Valeur par défaut	Description
`object`	string	-	`llm`, `image` ou `video`
`status`	string	-	`pending`, `in_progress`, `completed`, `failed` ou `cancelled`
`model`	string	-	Filtre exact par nom de modèle
`after`	string	-	Curseur de pagination
`limit`	integer	`20`	Plage de `1` à `100`
`order`	string	`desc`	`asc` ou `desc`

Détail d’une tâche unifiée :

curl https://aihubmix.com/ai/v1/tasks/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

Élément output unifié d’une tâche média :

{
  "index": 0,
  "result_id": "result_01K0XYZ",
  "type": "file",
  "content_type": "video/mp4",
  "content_url": "https://aihubmix.com/ai/v1/tasks/task_01K0ABCDEF/content"
}

Pour un résultat unique, demandez directement /ai/v1/tasks/{id}/content. Pour plusieurs résultats, demandez /ai/v1/tasks/{id}/content/{result_id}. Sans ID de résultat, l’API renvoie 400 result_id_required.

Les API de liste, de détail et de contenu des tâches unifiées sont isolées selon le Bearer Token qui a créé la tâche. Une autre clé API du même compte ne peut pas lire cette tâche.

Télécharger les résultats média

Télécharger des images

Une fois l’image terminée, demandez chaque output[].content_url de l’objet de tâche média :

curl "{content_url}" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output result.png

Le chemin de téléchargement média d’une image est /ai/v1/images/{id}/content/{result_id}. L’objet de tâche média n’expose pas result_id séparément. Le client peut utiliser directement content_url. Lorsque b64_json n’est pas vide, décodez directement ce champ en Base64.

Télécharger une vidéo

curl https://aihubmix.com/ai/v1/videos/{task_id}/content \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output result.mp4

Les résultats peuvent expirer et une limite de téléchargements peut s’appliquer. Une expiration renvoie 410 artifact_expired. Le dépassement de la limite renvoie 429 too_many_downloads.

Utiliser un Webhook

Les images asynchrones et les vidéos prennent en charge les Webhooks au niveau de la tâche :

curl -X POST https://aihubmix.com/ai/v1/videos \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan2.6-t2v",
    "prompt": "A tranquil garden at sunrise",
    "duration": 5,
    "size": "1280x720",
    "webhook_url": "https://example.com/webhooks/aihubmix",
    "webhook_events_filter": ["completed", "failed"]
  }'

webhook_url est limité à 512 caractères et ne peut pas pointer vers la machine locale, un réseau privé ou une autre adresse restreinte. Lorsque webhook_events_filter est omis, la plateforme envoie completed, failed et cancelled. Lorsqu’il est fourni, le tableau ne peut pas être vide ni contenir de doublons, et doit être utilisé avec webhook_url. Si webhook_url est absent de la requête, les images asynchrones et les vidéos tentent d’utiliser l’adresse de rappel par défaut du compte. Une adresse par défaut non valide est ignorée et ne bloque pas la création de la tâche.

Requête de rappel

{
  "event_id": "evt_01K0ABCDEF",
  "event_type": "completed",
  "created_at": "2026-08-12T12:00:00Z",
  "data": {
    "task_id": "task_01K0ABCDEF",
    "status": "completed",
    "model": "wan2.6-t2v",
    "results": [
      {
        "url": "https://aihubmix.com/ai/v1/tasks/task_01K0ABCDEF/content"
      }
    ]
  }
}

Champ	Description
`event_id`	ID de l’événement de rappel, utilisé pour la déduplication
`event_type`	`completed`, `failed` ou `cancelled`
`created_at`	Date de l’événement au format RFC 3339
`data.task_id`	ID de tâche de la plateforme
`data.status`	Statut final actuel
`data.model`	Nom du modèle
`data.results[].url`	Adresse de téléchargement éventuellement renvoyée à la fin
`data.error`	Informations d’erreur éventuellement renvoyées en cas d’échec

results n’apparaît que si le résultat a été archivé. Le téléchargement nécessite toujours un Bearer Token.

Nouvelles tentatives et déduplication

La plateforme utilise une livraison au moins une fois. Un même événement peut être envoyé plusieurs fois :

HTTP 2xx indique une réception réussie.
HTTP 5xx, une erreur réseau ou un délai dépassé déclenchent une nouvelle tentative.
HTTP 3xx et 4xx ne déclenchent pas de nouvelle tentative.
Six livraisons au maximum, avec des intervalles successifs de 1, 4, 16, 64 et 256 secondes.

Le destinataire doit enregistrer event_id et renvoyer immédiatement 2xx s’il reçoit à nouveau le même événement.

Le Webhook au niveau de la tâche n’a pas de clé de signature indépendante. Si une vérification de signature est nécessaire, configurez un abonnement Webhook au niveau du compte et conservez la consultation du détail de la tâche comme méthode de confirmation du résultat.

Fonctionnement de la reprise après interruption LLM

La reprise après interruption LLM permet de récupérer la réponse finale après la déconnexion du client. Le mode de requête, le comportement en streaming et le format de réponse restent inchangés. Aucun ID de tâche n’est renvoyé à l’avance au début de la requête. Les conditions suivantes doivent être remplies simultanément :

Condition	Description
Tâches asynchrones activées pour le compte	Activation du compte courant dans la console AIHubMix
Modèle compatible avec la reprise	Le modèle courant figure dans la liste des modèles de reprise après interruption LLM
API prise en charge	Chat Completions, Anthropic Messages, Responses API ou Gemini `generateContent` / `streamGenerateContent`
Interruption du client	Annulation par le client, coupure réseau ou annulation de la requête par l’appelant

La plateforme crée une tâche de reprise et enregistre le JSON ou le SSE final uniquement lorsqu’elle détecte que la réponse n’a pas été entièrement livrée et que le client s’est déconnecté. Une requête LLM terminée normalement et entièrement livrée au client ne crée pas de tâche de reprise. Les en-têtes de réponse LLM contiennent X-Aihubmix-Request-Id. Le client doit enregistrer cette valeur au plus tôt pour retrouver la requête correspondante dans la console. L’API publique de tâches ne permet pas actuellement de filtrer par ID de requête. Vous pouvez consulter les tâches LLM récentes par modèle et date de création :

curl "https://aihubmix.com/ai/v1/tasks?object=llm&model={model}&order=desc&limit=20" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

curl https://aihubmix.com/ai/v1/tasks/{task_id}/content \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

L’élément output unifié d’une tâche LLM contient type=response, content_type, content_url et truncated. GET /ai/v1/tasks/{id}/content renvoie le JSON ou le SSE d’origine enregistré.

Les tâches de reprise après interruption LLM n’envoient actuellement pas de Webhook au niveau de la tâche. Une interruption du client n’arrête pas le traitement de la requête par la plateforme. L’appel reste facturé selon les règles de l’API d’origine.

Réponses et codes d’erreur

Cette section s’applique à /ai/v1/images/*, /ai/v1/videos/* ainsi qu’aux tâches média de /ai/v1/tasks/* dont object=image ou object=video. Le client doit gérer à la fois les réponses HTTP hors 2xx et l’état final HTTP 200 avec status=failed.

{
  "error": {
    "message": "Task not found.",
    "type": "invalid_request_error",
    "code": "task_not_found",
    "tid": "req_01K0ABCDEF"
  }
}

Envoyer un retour pour une erreur HTTP 5xx

Lorsqu’une requête renvoie HTTP 5xx, envoyez un retour en joignant error.tid.

Erreurs HTTP hors 2xx

Les lignes invalid_request et schema_violation présentent des messages de repli. Lorsque le service peut identifier un champ ou une contrainte de paramètre, il renvoie un message dynamique. Le client doit classer l’erreur d’après son code et ne pas rechercher une correspondance exacte du message.

HTTP	`code`	`message`	Description
400	`invalid_request`	`Invalid request. Check the request body and parameters.` (modèle de repli ; le message réel peut être dynamique)	Le corps de requête commun, le type d’un champ ou un paramètre de liste est incorrect ; le message associé à ce code n’est pas fixe et devient plus précis lorsqu’un champ peut être identifié
400	`model_not_found`	`The requested model is not available. Check the model name and your account access.`	Le modèle n’existe pas, n’est pas disponible ou n’est pas accessible au compte actuel
400	`schema_violation`	`Invalid request: one or more parameters are invalid.` (modèle de repli ; le message réel peut être dynamique)	La requête ne respecte pas le Schema de paramètres du modèle actuel ; le message associé à ce code n’est pas fixe et devient dynamique lorsqu’un champ ou une contrainte peut être identifié
400	`capability_not_supported`	`The requested parameters are not supported for this model.`	Le modèle actuel ne prend pas en charge certains champs, quantités ou limites de paramètres de la requête
400	`media_form_unsupported`	Message média dynamique, voir ci-dessous	Le format, les données, l’URL ou la taille d’une image, d’une vidéo, d’une image de référence ou d’une première ou dernière image ne peut pas être traité
400	`result_id_required`	`This task has multiple results. Specify result_id.`	La tâche contient plusieurs résultats et aucun `result_id` n’a été précisé pour le téléchargement
400	`upstream_rejected`	`Upstream service rejected the request.`	Le fournisseur de modèles a rejeté la requête de création
401	`authentication_failed`	`Authentication failed: invalid or missing API key.`	La clé API est absente ou non valide
402	`insufficient_quota`	`Insufficient quota.`	Le quota disponible du compte AIHubMix est insuffisant
403	`permission_denied`	`You do not have permission to access this resource.`	Le compte, la clé API ou l’origine de l’accès ne permet pas d’utiliser cette ressource
403	`async_not_enabled`	`Asynchronous tasks are not enabled. Please go to <console-url>/async-tasks to activate.`	Les tâches asynchrones ne sont pas activées pour ce compte ; l’adresse de la console est générée selon le site de la requête
404	`task_not_found`	`Task not found.`	La tâche n’existe pas, le curseur de pagination est non valide ou le compte actuel ne peut pas la consulter
404	`result_not_found`	`Result not found.`	Le résultat n’existe pas, n’est pas encore prêt, ne correspond pas à l’ID fourni ou ne peut pas être téléchargé par le compte actuel
410	`artifact_expired`	`The result has expired.`	La durée de conservation du résultat est dépassée
413	`request_too_large`	`Request body is too large. Reduce the request size and try again.`	Le corps complet de la requête dépasse 32 MiB
413	`image_too_large`	`Image is too large. Reduce the image size and try again.`	Une image décodée par l’API d’images dépasse la limite de traitement du modèle
422	`image_not_generated`	`The expected image was not generated.`	Le fournisseur de modèles a terminé la requête sans renvoyer d’image exploitable
429	`rate_limited`	`Too many requests. Please slow down and retry.`	AIHubMix limite le débit du compte ou de la clé API actuelle
429	`upstream_rate_limited`	`Upstream service is rate limiting. Please retry later.`	Le fournisseur de modèles a renvoyé une erreur de limitation de débit
429	`too_many_downloads`	`Download limit exceeded for this result.`	Le nombre maximal de téléchargements d’un résultat est atteint
500	`internal_error`	`Internal error. Please retry.`	Une erreur interne que l’appelant ne peut pas corriger s’est produite
502	`upstream_unreachable`	`Upstream service is temporarily unavailable. Please retry.`	Impossible de joindre le fournisseur de modèles ou de lire sa réponse dans son intégralité
502	`upstream_bad_response`	`Upstream service returned an invalid response.`	Le fournisseur de modèles a renvoyé une réponse que la plateforme ne peut pas traiter
502	`upstream_error`	`Upstream service is temporarily unavailable. Please retry.`	Le fournisseur de modèles a renvoyé une erreur de service
503	`model_unavailable`	`The requested model is temporarily unavailable.`	Le modèle sélectionné est temporairement indisponible
503	`service_unavailable`	`Service is temporarily unavailable. Please retry.`	Le service de consultation, de téléchargement ou de résultats est temporairement indisponible
504	`sync_timeout`	`Generation timed out. Please retry.`	La génération synchrone ne s’est pas terminée dans le délai d’attente

Le message de media_form_unsupported est généré selon la cause confirmée. Les modèles courants sont les suivants :

Cas	`message`
Format non pris en charge	`Unsupported <media-kind> format: <detected-format>. Supported formats for this model: <allowed-formats>.`
Données d’image ou de vidéo non valides	`The <media-kind> data is invalid. Provide a valid <media-kind>.`
Données non valides lorsque le type de média ne peut pas être déterminé	`The media data is invalid. Provide valid media data.`
URL du média inaccessible	`The <media-kind> URL could not be accessed. Make sure it is publicly accessible and returns a valid <media-kind>.`
Média impossible à décoder	`Unable to process the <media-kind>. Check that the <media-kind> data or URL is valid and supported.`
Média d’une tâche autre qu’une image dépassant la limite	`The <media-kind> is too large. Reduce the <media-kind> size and try again.`
Cause précise impossible à déterminer de manière fiable	`Unable to process the media. Check that the media data or URL is valid and supported.`

Par exemple, lorsqu’un modèle accepte PNG, JPEG, WebP, HEIC et HEIF, une image GIF renvoie :

Unsupported image format: GIF. Supported formats for this model: PNG, JPEG, WebP, HEIC, and HEIF.

HTTP 200 + Task `status=failed`

Une requête de consultation réussie ne signifie pas que la génération a réussi. Lorsque la tâche est failed, le client lit la cause dans error.code et error.message de l’objet de tâche :

{
  "id": "task_01K0ABCDEF",
  "status": "failed",
  "error": {
    "code": "media_form_unsupported",
    "message": "Unsupported image format: GIF. Supported formats for this model: PNG, JPEG, WebP, HEIC, and HEIF."
  }
}

Task `code`	`message`	Description
`media_form_unsupported`	Message média dynamique, comme ci-dessus	Erreur de format, de données, d’URL, de décodage ou de taille du média dans une tâche asynchrone
`image_too_large`	`Image is too large. Reduce the image size and try again.`	L’image d’entrée d’une tâche d’image asynchrone dépasse la limite
`image_not_generated`	`The expected image was not generated.`	Le fournisseur de modèles n’a pas renvoyé d’image exploitable
`upstream_rejected`	`Upstream service rejected the request.`	Le fournisseur de modèles a rejeté la requête de création
`upstream_rate_limited`	`Upstream service is rate limiting. Please retry later.`	Le fournisseur de modèles a renvoyé une erreur de limitation de débit
`upstream_unreachable`	`Upstream service is temporarily unavailable. Please retry.`	Impossible de joindre le fournisseur de modèles lors de la création de la tâche ou de lire sa réponse dans son intégralité
`upstream_bad_response`	`Upstream service returned an invalid response.`	La réponse du fournisseur de modèles ne peut pas être traitée
`upstream_error`	`Upstream service is temporarily unavailable. Please retry.`	Le fournisseur de modèles n’a pas pu créer ou exécuter la tâche
`upstream_empty_output`	`The upstream service completed without producing a usable result. Please retry.`	Le fournisseur de modèles a terminé la tâche sans produire de résultat exploitable
`output_policy_violation`	`Generated content was rejected by the content policy.`	Le contenu généré n’a pas satisfait à la politique de contenu
`sync_timeout`	`Generation timed out. Please retry.`	L’attente du résultat de génération a expiré
`internal_error`	`Internal error. Please retry.`	Une erreur interne s’est produite pendant le traitement de la tâche asynchrone

Exemple vidéo complet

import os
import time

import requests

base_url = "https://aihubmix.com"
headers = {
    "Authorization": f"Bearer {os.environ['AIHUBMIX_API_KEY']}",
    "Content-Type": "application/json",
}

response = requests.post(
    f"{base_url}/ai/v1/videos",
    headers=headers,
    json={
        "model": "wan2.6-t2v",
        "prompt": "A cat playing jazz on a piano",
        "duration": 5,
        "size": "1280x720",
    },
    timeout=60,
)
response.raise_for_status()
task = response.json()

while task["status"] not in {"completed", "failed", "cancelled"}:
    time.sleep(15)
    response = requests.get(
        f"{base_url}/ai/v1/videos/{task['id']}",
        headers=headers,
        timeout=30,
    )
    response.raise_for_status()
    task = response.json()

if task["status"] == "completed":
    result = requests.get(
        f"{base_url}/ai/v1/videos/{task['id']}/content",
        headers=headers,
        timeout=120,
    )
    result.raise_for_status()
    with open("result.mp4", "wb") as file:
        file.write(result.content)
else:
    raise RuntimeError(task.get("error") or task["status"])

import { writeFile } from "node:fs/promises";

const baseUrl = "https://aihubmix.com";
const headers = {
  Authorization: `Bearer ${process.env.AIHUBMIX_API_KEY}`,
  "Content-Type": "application/json",
};

const created = await fetch(`${baseUrl}/ai/v1/videos`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    model: "wan2.6-t2v",
    prompt: "A cat playing jazz on a piano",
    duration: 5,
    size: "1280x720",
  }),
});
if (!created.ok) throw new Error(await created.text());
let task = await created.json();

const finished = new Set(["completed", "failed", "cancelled"]);
while (!finished.has(task.status)) {
  await new Promise((resolve) => setTimeout(resolve, 15_000));
  const polled = await fetch(`${baseUrl}/ai/v1/videos/${task.id}`, { headers });
  if (!polled.ok) throw new Error(await polled.text());
  task = await polled.json();
}

if (task.status === "completed") {
  const result = await fetch(`${baseUrl}/ai/v1/videos/${task.id}/content`, {
    headers,
  });
  if (!result.ok) throw new Error(await result.text());
  await writeFile("result.mp4", Buffer.from(await result.arrayBuffer()));
} else {
  throw new Error(JSON.stringify(task.error ?? task.status));
}

Questions fréquentes

Faut-il consulter une tâche média via /ai/v1/tasks/{id} ou via l’API de détail média ? Utilisez l’API de détail média pour suivre le statut de génération : /ai/v1/images/{id} pour une image et /ai/v1/videos/{id} pour une vidéo. /ai/v1/tasks/{id} renvoie un instantané en lecture seule. Pourquoi le champ seconds d’une requête vidéo provoque-t-il une erreur de paramètre ? Le protocole standard /ai/v1/videos utilise l’entier duration, exprimé en secondes. Les valeurs autorisées dépendent des paramètres pris en charge par le modèle. Pourquoi resolution provoque-t-il une erreur avec certains modèles vidéo ? Le protocole vidéo standard contient resolution et size, mais chaque modèle peut limiter les champs. Par exemple, wan2.6-t2v utilise size et n’accepte pas resolution. Comment retrouver une tâche média après la perte de la réponse de création ? Demandez GET /ai/v1/images pour une image ou GET /ai/v1/videos pour une vidéo. Les listes prennent en charge les paramètres de pagination after, limit et order. Pourquoi les champs output diffèrent-ils entre les deux API de détail ? L’API de détail média fournit les champs simplifiés nécessaires au téléchargement direct. L’API de tâches unifiées fournit également result_id et content_type, ainsi que truncated pour les archives LLM. Que faire si le Webhook n’est pas reçu ? Vérifiez que l’adresse de rappel est accessible publiquement et renvoie rapidement 2xx, puis consultez le statut final avec l’API de détail média.

Date de mise à jour : 2026-08-12

Tutoriel vidéo : tâches asynchrones

Activer les tâches asynchrones dans la console

​Démarrage rapide

​Comment choisir entre les trois groupes d’API ?

​Différences entre les API média et l’API de tâches unifiées

​Comment découvrir les modèles média asynchrones et obtenir leurs schémas ?

​Lister les modèles compatibles avec les API asynchrones

​Obtenir le schéma de requête d’un modèle

​Modèles et champs pris en charge

​Modèles de reprise après interruption LLM

​Comment créer une tâche d’image ?

​Image synchrone

​Image asynchrone

​Champs standard des images

​Comment créer une tâche vidéo ?

​Champs standard des vidéos

​Objet de tâche média

​Description des statuts

​Comment consulter les tâches média ?

​Consulter le détail d’un média

​Lister les médias

​Comment utiliser l’API de tâches unifiées ?

​Télécharger les résultats média

​Télécharger des images

​Télécharger une vidéo

​Utiliser un Webhook

​Requête de rappel

​Nouvelles tentatives et déduplication

​Fonctionnement de la reprise après interruption LLM

​Réponses et codes d’erreur

Envoyer un retour pour une erreur HTTP 5xx

​Erreurs HTTP hors 2xx

​HTTP 200 + Task status=failed

​Exemple vidéo complet

​Questions fréquentes

Démarrage rapide

Comment choisir entre les trois groupes d’API ?

Différences entre les API média et l’API de tâches unifiées

Comment découvrir les modèles média asynchrones et obtenir leurs schémas ?

Lister les modèles compatibles avec les API asynchrones

Obtenir le schéma de requête d’un modèle

Modèles et champs pris en charge

Modèles de reprise après interruption LLM

Comment créer une tâche d’image ?

Image synchrone

Image asynchrone

Champs standard des images

Comment créer une tâche vidéo ?

Champs standard des vidéos

Objet de tâche média

Description des statuts

Comment consulter les tâches média ?

Consulter le détail d’un média

Lister les médias

Comment utiliser l’API de tâches unifiées ?

Télécharger les résultats média

Télécharger des images

Télécharger une vidéo

Utiliser un Webhook

Requête de rappel

Nouvelles tentatives et déduplication

Fonctionnement de la reprise après interruption LLM

Réponses et codes d’erreur

Erreurs HTTP hors 2xx

HTTP 200 + Task `status=failed`

Exemple vidéo complet

Questions fréquentes