Démarrage rapide de l’API PixMind : générer des images avec Node.js

L’acceptation d’une requête de génération d’images ne signifie pas que l’image est prête. Votre application doit conserver l’identifiant de la tâche, vérifier l’état de cette même tâche et gérer l’échec ou l’interruption d’une requête sans lancer accidentellement une autre génération.

Ce tutoriel vous propose de créer un petit client Node.js côté serveur pour gérer cette séquence. Il distingue deux commandes, submit et resume : la première crée une tâche, tandis que la seconde vérifie uniquement une tâche existante. Commencez par consulter les identifiants de modèles pris en charge par l’API, plutôt que de recopier un nom de modèle affiché sur une bannière de la page d’accueil.

Le tutoriel porte sur la génération d’images à partir de texte. Il ne couvre ni l’envoi de fichiers de référence, ni la création d’une interface dans le navigateur, ni l’évaluation de la qualité des modèles. La validation combine 29 tests locaux avec des réponses simulées et une seule tâche de génération d’image exécutée de manière contrôlée en production le 4 septembre 2026. Cette tâche a renvoyé une image et donné lieu à une facturation API de 120 points. Il s’agit d’une vérification d’intégration ponctuelle et datée, pas d’un test de vitesse, d’un tarif universel ou d’une garantie de disponibilité pour un autre compte.

L’image de couverture est une capture d’écran du catalogue des modèles réalisée le 4 septembre 2026. Considérez-la comme une illustration datée, et non comme un tarif en vigueur ou une garantie de disponibilité.

Points essentiels

• Conservez la clé API sur votre serveur, en dehors des fichiers JavaScript livrés au navigateur et des dépôts publics.
• Pour une tâche de génération d’image, récupérez la valeur numérique data.taskId dans la réponse d’acceptation et conservez-la pour les requêtes suivantes.
• Interrogez périodiquement la tâche enregistrée jusqu’à ce qu’elle atteigne l’état ready ou failed. Ne lisez les URL des images dans data.images qu’une fois la tâche réussie.
• L’expiration du délai d’attente côté client ne prouve pas que la tâche distante a échoué ou a été annulée. Reprenez les requêtes si vous disposez d’un identifiant de tâche ; ne répétez pas aveuglément la requête de création.

Dans ce guide

• Avant de commencer
• Choisir un modèle et configurer votre clé API
• Envoyer une requête avec cURL
• Interroger la tâche et lire les URL des images
• Exemple Node.js complet
• Gérer les erreurs
• Différences pour la vidéo et le chat
• Vérifier votre intégration

Avant de commencer

Utilisez un terminal privé ou un environnement serveur avec Node.js, une clé API et un compte configuré pour la facturation API. L’exemple fourni utilise la fonction native fetch et les modules JavaScript, sans installation de paquet tiers. La documentation des API globales de Node.js décrit fetch et AbortSignal.timeout, que le client utilise pour limiter la durée d’une requête individuelle. L’environnement de validation locale est Windows avec Node.js v22.22.1 ; cette précision décrit l’environnement de test, sans prétendre que toutes les autres versions ont été testées.

Vous devez savoir modifier un fichier, définir une variable d’environnement et lire du JSON. Vérifiez la version de votre environnement d’exécution avant de continuer :

node --version

La commande doit afficher la version installée. Elle ne contacte pas l’API de génération. Enregistrez le client complet présenté plus loin sous le nom examples/pixmind-image.mjs dans un dossier de travail, puis exécutez ses commandes depuis ce dossier.

Choisissez un prompt de test anodin, sans données de clients ni informations confidentielles. Ce tutoriel utilise une tasse à café en céramique sur un fond de studio ; aucun fichier de référence n’est donc nécessaire. Consultez le tarif API actuel du modèle sélectionné avant d’envoyer votre requête. Ne présumez pas que les crédits Studio, les abonnements et la facturation API sont interchangeables ; le catalogue des modèles présente l’offre API applicable.

Si vous souhaitez simplement créer une image de manière interactive, le guide de l’Agent Image explique cette démarche. Le client présenté ici s’adresse à une application qui fournit explicitement un identifiant de modèle et traite elle-même la réponse.

Choisir un modèle et configurer votre clé API

Utilisez un identifiant de modèle pris en charge par l’API et des paramètres compatibles avec ce modèle. L’exemple choisit nano-banana-pro, avec aspectRatio: "1:1" et resolution: "1K", conformément à la requête de génération d’image du guide de démarrage rapide de l’API. Une requête authentifiée GET /models et le test en production ont confirmé cette combinaison pour le compte de test le 4 septembre 2026. Vérifiez à nouveau la disponibilité et la prise en charge des paramètres pour votre propre compte avant une exécution réelle. Modifier uniquement le nom du modèle ne garantit pas que le reste de la requête demeure valide.

Créez une clé dans la console API, puis transmettez-la au processus serveur via PIXMIND_API_KEY. Utilisez votre mécanisme privé de gestion des secrets si vous en disposez. Les exemples suivants illustrent la syntaxe des variables d’environnement avec une valeur fictive, et non un identifiant utilisable.

Pour PowerShell :

$env:PIXMIND_API_KEY = "REPLACE_WITH_YOUR_PRIVATE_API_KEY"
$env:PIXMIND_MODEL = "nano-banana-pro"
$env:PIXMIND_PROMPT = "A ceramic coffee cup on a plain studio background, soft side lighting, no text"

Pour Bash :

export PIXMIND_API_KEY="REPLACE_WITH_YOUR_PRIVATE_API_KEY"
export PIXMIND_MODEL="nano-banana-pro"
export PIXMIND_PROMPT="A ceramic coffee cup on a plain studio background, soft side lighting, no text"

Ces affectations configurent le shell en cours et les processus lancés depuis celui-ci. Elles ne créent aucune tâche. Protégez l’historique du shell et les enregistrements de session lorsque vous saisissez un véritable secret, et ne l’ajoutez jamais à votre dépôt de code. Suivez les consignes d’authentification pour utiliser des clés distinctes en développement et en production, et pour les renouveler après une exposition.

L’URL de base de ce tutoriel est la suivante :

https://aihub-admin.aimix.pro/api-platform/v1

Ajoutez /generations ou /tasks/{taskId} à cette base. N’ajoutez pas un second /v1. La liste des modèles est accessible via GET /models ; le catalogue reste le moyen le plus pratique de consulter les capacités propres à chaque modèle avant de choisir les paramètres.

Envoyer votre première requête de génération d’image avec cURL

La requête cURL est une alternative à la commande Node.js submit, et non une étape de configuration à exécuter au préalable. Toutes deux envoient une requête de génération. Les exécuter toutes les deux peut créer deux tâches facturables. Si vous envoyez la requête avec cURL, utilisez ensuite la commande Node.js resume avec l’identifiant de tâche renvoyé.

Cet exemple utilise la syntaxe Bash. Dans PowerShell, utilisez le client Node.js ci-dessous au lieu de coller dans le terminal les caractères de continuation de ligne de Bash.

curl --connect-timeout 10 --max-time 30 \
  --request POST \
  'https://aihub-admin.aimix.pro/api-platform/v1/generations' \
  --header "Authorization: Bearer $PIXMIND_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "nano-banana-pro",
    "type": "image",
    "prompt": "A ceramic coffee cup on a plain studio background, soft side lighting, no text",
    "aspectRatio": "1:1",
    "resolution": "1K"
  }'

Le prompt et les paramètres du corps de cette requête cURL sont des valeurs littérales. Modifier PIXMIND_PROMPT ne change pas ce JSON ; cette variable d’environnement est lue par le client Node.js. Cette distinction permet de séparer clairement la requête que vous souhaitez envoyer de la configuration du shell qui l’entoure.

Vous trouverez ci-dessous un exemple abrégé de réponse d’acceptation. Son identifiant est fictif, ce n’est pas celui du test en production ; 12345 n’est pas une tâche que vous devez interroger.

{
  "code": 1000,
  "message": "success",
  "data": {
    "id": "img_12345",
    "taskId": 12345
  }
}

Les réponses de l’API média testées en production encapsulaient les données de succès dans un objet comportant code, message, data et timestamp ; l’illustration omet l’horodatage et d’autres champs. Dans ce flux, la réussite exige à la fois une réponse HTTP de succès et une réponse applicative valide. Lisez data.taskId, et non data.id : ce dernier peut contenir une chaîne préfixée telle que img_12345, alors que le chemin de consultation d’une tâche utilise l’identifiant numérique.

Enregistrez immédiatement cet identifiant numérique. Si la requête expire avant que vous ne le receviez, arrêtez-vous et vérifiez le résultat de l’envoi dans l’historique des tâches de votre compte ou auprès de l’assistance. Répéter le POST n’est pas une solution sûre pour déterminer ce qui s’est passé.

Interrogation périodique des tâches et lecture des URL des images

Interrogez la tâche existante jusqu’à ce qu’elle atteigne un état final. La documentation des tâches asynchrones décrit les états pending, processing, ready et failed. Seuls les deux derniers mettent fin à cette interrogation périodique.

Submit once
    |
Save numeric taskId
    |
GET /tasks/{taskId} <--- wait, then query again
    |                            ^
    +--- pending / processing ---+
    |
    +--- ready  ---> read images, stop
    |
    +--- failed ---> report failure, stop

Pour effectuer une requête manuelle dans Bash, remplacez l’identifiant fictif par le vôtre :

TASK_ID="REPLACE_WITH_YOUR_NUMERIC_TASK_ID"
curl --connect-timeout 10 --max-time 30 \
  "https://aihub-admin.aimix.pro/api-platform/v1/tasks/$TASK_ID" \
  --header "Authorization: Bearer $PIXMIND_API_KEY"

Dans le format actuel des réponses de l’API média, les champs dont vous avez besoin remplissent des fonctions différentes :

Une réponse ready sans URL d’image exploitable n’est pas un résultat image réussi pour votre application. Signalez cette incohérence avec l’identifiant de la tâche afin qu’elle puisse être examinée. Ne remplacez pas l’URL manquante par une URL d’exemple et n’annoncez pas qu’une image a été téléchargée.

Le client affiche les URL des images renvoyées ; il ne récupère pas les fichiers image et ne les archive pas. Si votre application a besoin d’un stockage durable, prévoyez cette opération comme une étape distincte et vérifiez les conditions de conservation et d’utilisation des ressources concernées. La présence d’une URL ne constitue pas une garantie de stockage permanent.

Exécuter l’exemple Node.js complet de génération d’images

Utilisez submit pour une nouvelle tâche, ou resume pour une tâche existante. Exécuter le script sans argument affiche l’aide et n’effectue aucun appel API. Ce comportement par défaut évite qu’un simple redémarrage ou une consultation rapide de l’interface en ligne de commande ne crée une nouvelle tâche.

Enregistrez le code source complet ci-dessous sous le nom examples/pixmind-image.mjs :

import { pathToFileURL } from 'node:url';

const BASE_URL = 'https://aihub-admin.aimix.pro/api-platform/v1';
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

export class ApiError extends Error {
  constructor(message, { status = 0, transient = false, retryAfterMs = 0 } = {}) {
    super(message);
    Object.assign(this, { status, transient, retryAfterMs });
  }
}

export function parseTaskId(value) {
  if (!/^\d+$/.test(String(value))) throw new Error('Use a numeric taskId, not img_...');
  const id = Number(value);
  if (!Number.isSafeInteger(id) || id <= 0) throw new Error('Invalid taskId');
  return id;
}

export function retryAfter(value, now) {
  if (!value) return 0;
  if (/^\d+(\.\d+)?$/.test(value)) return Number(value) * 1000;
  const date = Date.parse(value);
  return Number.isFinite(date) ? Math.max(0, date - now) : 0;
}

export function createClient({
  apiKey,
  fetchImpl = fetch,
  now = Date.now,
  wait = sleep,
  random = Math.random,
  requestTimeoutMs = 30_000,
  pollTimeoutMs = 300_000,
  maxConsecutiveErrors = 5,
} = {}) {
  if (typeof apiKey !== 'string' || !apiKey.trim()) throw new Error('Set PIXMIND_API_KEY');

  async function request(path, method, payload, timeoutMs = requestTimeoutMs) {
    let response;
    let body;
    try {
      response = await fetchImpl(`${BASE_URL}${path}`, {
        method,
        redirect: 'error',
        headers: {
          Authorization: `Bearer ${apiKey}`,
          ...(payload ? { 'Content-Type': 'application/json' } : {}),
        },
        ...(payload ? { body: JSON.stringify(payload) } : {}),
        signal: AbortSignal.timeout(Math.max(1, Math.ceil(timeoutMs))),
      });
      // Read the body inside the timeout/network error boundary as well.
      body = await response.text();
    } catch {
      throw new ApiError('Network error or request timeout', { transient: true });
    }
    let envelope;
    try { envelope = JSON.parse(body); } catch { /* handle below */ }
    const transient = response.status === 429 || response.status >= 500;
    if (!response.ok) {
      // Do not echo arbitrary server bodies, prompts, credentials, or output URLs.
      throw new ApiError(`HTTP ${response.status}; inspect the account and request`, {
        status: response.status,
        transient,
        retryAfterMs: retryAfter(response.headers.get('retry-after'), now()),
      });
    }
    if (!envelope || typeof envelope !== 'object') {
      throw new ApiError('Expected a JSON API response');
    }
    if (envelope.code !== 1000 || !envelope.data) {
      throw new ApiError('API returned an unsuccessful or incomplete envelope');
    }
    return envelope.data;
  }

  async function submit({ model = 'nano-banana-pro', prompt } = {}) {
    if (typeof model !== 'string' || !model.trim()) throw new Error('A model is required');
    if (typeof prompt !== 'string' || !prompt.trim()) throw new Error('A prompt is required');
    try {
      const data = await request('/generations', 'POST', {
        model, type: 'image', prompt, aspectRatio: '1:1', resolution: '1K',
      });
      // The public media contract returns a number, not the prefixed display ID.
      if (typeof data.taskId !== 'number') throw new Error('Missing numeric taskId');
      return parseTaskId(data.taskId);
    } catch (error) {
      // A timeout or malformed response does not prove that creation failed.
      throw new Error(`Submission not confirmed: ${error.message}. No automatic retry was made. Check task records before submitting again.`);
    }
  }

  async function poll(taskId) {
    const id = parseTaskId(taskId);
    const deadline = now() + pollTimeoutMs;
    let attempts = 0;
    let errors = 0;
    const timedOut = () => new Error(`Stopped waiting for task ${id}; it may still be running. Resume this ID later.`);
    while (now() < deadline) {
      let retryFloor = 0;
      let task;
      try {
        task = await request(`/tasks/${id}`, 'GET', undefined,
          Math.min(requestTimeoutMs, deadline - now()));
        errors = 0;
      } catch (error) {
        if (now() >= deadline) throw timedOut();
        if (!(error instanceof ApiError) || !error.transient) throw error;
        errors += 1;
        if (errors >= maxConsecutiveErrors) {
          throw new Error(`Stopped after ${errors} consecutive query errors for task ${id}; resume this ID later.`);
        }
        retryFloor = error.retryAfterMs;
      }
      if (now() >= deadline) throw timedOut();
      if (task) {
        if (task.taskId !== id) throw new Error('Task response ID does not match the requested task');
        if (task.status === 'failed') throw new Error(`Task ${id} failed; inspect its record before creating another task.`);
        if (task.status === 'ready') {
          if (!Array.isArray(task.images) || task.images.length === 0 ||
              !task.images.every(url => {
                try { return ['https:', 'http:'].includes(new URL(url).protocol); }
                catch { return false; }
              })) throw new Error(`Task ${id} is ready but has no valid image URLs`);
          return task.images;
        }
        if (!['pending', 'processing'].includes(task.status)) {
          throw new Error(`Task ${id} returned an unrecognized status; inspect its record.`);
        }
      }
      // Client policy, not a PixMind latency guarantee or server-side retry feature.
      const ceiling = Math.min(10_000, 1_000 * 2 ** Math.min(attempts++, 4));
      const delay = Math.max(retryFloor, ceiling * (0.5 + 0.5 * random()));
      const remaining = deadline - now();
      if (delay >= remaining) {
        // Never poll earlier than Retry-After just to fit the local deadline.
        await wait(Math.max(0, remaining));
        throw timedOut();
      }
      await wait(delay);
    }
    throw timedOut();
  }

  return { submit, poll };
}

export async function main(args = process.argv.slice(2), env = process.env, deps = {}) {
  const log = deps.log ?? console.log;
  const [mode, rawId] = args;
  if (!mode) {
    log('Usage: node examples/pixmind-image.mjs submit | resume TASK_ID');
    return;
  }
  if (!((mode === 'submit' && args.length === 1) || (mode === 'resume' && args.length === 2))) {
    throw new Error('Use submit, or resume followed by a numeric taskId');
  }
  const resumeId = mode === 'resume' ? parseTaskId(rawId) : undefined;
  const client = createClient({ ...deps, apiKey: env.PIXMIND_API_KEY });
  const id = resumeId ?? await client.submit({
    model: env.PIXMIND_MODEL || 'nano-banana-pro',
    prompt: env.PIXMIND_PROMPT || 'A studio photograph of an unbranded ceramic coffee cup on a plain background',
  });
  // Save this line in your application record before relying on the polling process.
  log(`TASK_ID=${id}`);
  log(`Resume without a new generation: node examples/pixmind-image.mjs resume ${id}`);
  const images = await client.poll(id);
  log(JSON.stringify({ taskId: id, images }, null, 2));
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  main().catch(error => { console.error(error.message); process.exitCode = 1; });
}

Commencez par consulter l’interface de commande sans rien envoyer :

node examples/pixmind-image.mjs

Après avoir vérifié la clé, les paramètres du modèle et le montant attendu, créez une seule tâche :

node examples/pixmind-image.mjs submit

Lorsque la création réussit, le client affiche immédiatement TASK_ID, avant d’attendre l’image. Copiez la valeur réelle dans un emplacement privé. Cet exemple ne l’enregistre ni dans un fichier ni dans une base de données ; fermer le terminal peut donc vous faire perdre la référence nécessaire à la reprise si vous n’avez pas conservé la sortie.

Pour continuer à interroger une tâche, remplacez 12345 par cette valeur enregistrée :

node examples/pixmind-image.mjs resume 12345

Cette commande effectue uniquement des requêtes GET de consultation de tâche. Elle ne lit pas un nouveau prompt pour créer une autre image. Un état final de réussite doit produire des URL de sortie pour votre propre tâche ; aucun résultat de production fictif n’est fourni ici à titre de référence.

L’exemple fixe une limite de 30 secondes par requête HTTP et une durée maximale de cinq minutes pour l’interrogation périodique. Les nouvelles tentatives GET utilisent un délai exponentiel avec une variation aléatoire, un plafond local de 10 secondes pour ce délai et, lorsqu’il s’applique, un en-tête de réponse Retry-After valide. Un délai plus long demandé par le serveur est prioritaire ; s’il ne tient pas dans le temps restant avant l’échéance locale, le client s’arrête sans envoyer de requête prématurée. La cinquième erreur GET transitoire consécutive met fin à la tentative, ce qui autorise quatre nouvelles tentatives dans cette série d’erreurs. Ces valeurs sont des paramètres du client, et non un accord de niveau de service ou la promesse que chaque image sera prête en moins de cinq minutes.

Choisissez une politique de durée totale d’attente adaptée à votre application. Une tâche longue peut se poursuivre au-delà d’une session de terminal ou d’une requête web. Dans un service déployé, enregistrez l’identifiant de la tâche avec votre propre enregistrement de traitement et exposez un point de terminaison distinct pour que le navigateur puisse consulter l’état, plutôt que d’obliger l’utilisateur à maintenir une connexion ouverte.

Gérer les erreurs sans dupliquer les générations payantes

Traitez une incertitude sur la création différemment de l’échec d’une requête de consultation d’état. Une requête GET de consultation de tâche peut être répétée sans créer une autre génération. Un POST de création dont la réponse a été perdue peut avoir déjà lancé le traitement ; l’exemple ne le renvoie donc jamais automatiquement.

Ne supposez pas que toutes les erreurs utilisent le même format de réponse. Lors de la vérification en production du 4 septembre, GET /models sans authentification a renvoyé HTTP 401 avec uniquement code et message ; les réponses de succès authentifiées de l’API média comprenaient également data et timestamp. Ce tutoriel ne garantit donc pas la présence d’un requestId, d’un indicateur retryable ou d’un champ de prix dans chaque réponse. Les autres cas d’erreur ci-dessus décrivent le traitement côté client, sans prétendre que chacun a été reproduit en production. Conservez le statut HTTP et, lorsqu’il est présent, un message applicatif expurgé des informations sensibles ; traitez les corps de réponse malformés comme des erreurs au lieu de laisser JSON.parse provoquer un plantage.

L’expiration du délai d’interrogation signifie que le client a cessé d’attendre, pas que la tâche distante a été annulée. Conservez l’identifiant et reprenez plus tard. Un état inconnu ne prouve pas non plus la réussite : ce client s’arrête et le signale pour examen. Ne passez jamais par défaut à « terminé » parce qu’une valeur n’était pas prévue dans une instruction de sélection conditionnelle.

Pour le dépannage, conservez l’identifiant de la tâche, celui du modèle, l’opération, le statut HTTP et l’heure approximative. Évitez d’enregistrer les en-têtes d’autorisation ou les corps de requête complets contenant des prompts privés. Vérifiez si les corps de réponse de diagnostic ou les URL de sortie contiennent des informations sensibles avant de les partager.

Adapter cette approche à la vidéo et au chat

La vidéo peut reprendre le même principe d’envoi puis d’interrogation périodique, mais elle nécessite sa propre validation des requêtes et son propre traitement des résultats. Vérifiez les médias d’entrée requis, la durée, la résolution et les options audio du modèle vidéo choisi, au lieu de réutiliser les champs de la requête image en supposant leur compatibilité. Une vidéo terminée utilise data.videoUrl, et non data.images.

Le guide de l’Agent Vidéo présente un processus créatif interactif. Il peut vous aider à définir le plan souhaité avant d’automatiser la génération, mais l’existence d’une fonctionnalité de l’Agent ne prouve pas qu’un paramètre API du même nom existe.

Le chat relève d’une intégration distincte. La route documentée /chat/completions est compatible avec OpenAI et renvoie une réponse de chat, ou un flux lorsque le mode de diffusion en continu est demandé. Ne transmettez pas cette réponse à l’analyseur de data.taskId du client image. Une URL de base commune n’implique pas une structure de réponse identique pour tous les points de terminaison.

Limitez le périmètre du client image tant que ce parcours n’est pas validé. Ajoutez séparément un adaptateur vidéo ou un client de chat, avec des tests de leur propre format de réponse. Cette séparation facilite la compréhension du code par rapport à une fonction unique qui devine si l’objet renvoyé est une tâche image, une tâche vidéo ou un message de chat.

Vérifier votre intégration et choisir la suite

Les tests locaux avec des réponses simulées vérifient le comportement du client sans consommer le solde API. La suite fournie a réussi 29 tests dans l’environnement Windows et Node.js indiqué, notamment pour l’envoi avec un seul POST, la reprise uniquement par GET, les réponses malformées, l’état final d’échec, les délais et les limites de nouvelles tentatives. Enregistrez le fichier de tests fourni à côté du code source du client, puis lancez la suite depuis le dossier du tutoriel :

node --test examples/pixmind-image.test.mjs

Les tests avec des réponses simulées ne valident ni la disponibilité en production ni la facturation. Une vérification contrôlée distincte, effectuée le 4 septembre 2026, a utilisé le même client dans le périmètre consigné ci-dessous :

La vérification a utilisé une clé API existante du projet, un prompt non sensible, aucun fichier de référence et aucune nouvelle tentative automatique de création. L’écriture de facturation a été rapprochée de l’identifiant de tâche, et non déduite d’un affichage du solde Studio. Seuls cette configuration et le parcours de génération d’image réussie ont été testés en conditions réelles ; la vidéo, le chat, la facturation en cas d’échec, les remboursements et la fiabilité sur des exécutions répétées ne l’ont pas été. Vérifiez de nouveau le prix avant votre propre envoi, plutôt que de considérer ce montant historique comme un tarif permanent.

Avant de relier l’exemple à un véritable parcours utilisateur, vérifiez les points suivants :

• La clé reste sur le serveur et n’apparaît ni dans les fichiers livrés au navigateur, ni dans les captures d’écran, ni dans les journaux publics.
• Le modèle sélectionné et chacun des paramètres sont pris en charge par l’offre API actuelle.
• Après l’acceptation d’une requête, vous disposez d’un identifiant numérique de tâche récupérable.
• resume n’effectue aucun POST de création, y compris après des erreurs transitoires de consultation.
• Un échec de tâche, un résultat vide et une expiration locale du délai d’attente produisent des diagnostics distincts.
• La perte d’une réponse de création ne déclenche pas un second envoi automatique.

Pour votre propre vérification contrôlée en conditions réelles, consignez le compte, le modèle, le périmètre de coût approuvé, la requête expurgée des informations sensibles, l’identifiant de tâche, la réponse finale et l’écriture de facturation réelle. Inspectez le résultat séparément de la simple vérification de l’existence de son URL. Ne multipliez pas les « tests rapides de bon fonctionnement » sans tenir compte du fait que chaque nouvel envoi peut déclencher un traitement payant.

Lorsque vous êtes prêt, créez une clé API et choisissez une seule méthode d’envoi. Commencez par le fonctionnement fondé sur la conservation des tâches avant d’ajouter des files d’attente, des envois de fichiers ou du traitement par lots. Si vous souhaitez ensuite intégrer les ressources générées à un processus de validation créative, le processus de création de publicité produit avec Canvas fournit un exemple distinct, piloté par une personne ; il ne promet pas que les projets Canvas peuvent être exécutés via cette API.

Responsabilité éditoriale : PixMind Editorial Team est la signature institutionnelle de ce tutoriel. Celui-ci s’appuie sur la documentation officielle, l’implémentation du contrôleur média du projet, 29 tests locaux avec des réponses simulées et l’unique vérification en production décrite ci-dessus, tous examinés le 4 septembre 2026. Les relevés de tâches et de facturation expurgés des informations sensibles sont conservés à des fins de vérification éditoriale. Le tutoriel ne revendique ni les qualifications d’un ingénieur en particulier, ni un résultat comparatif de qualité des modèles, ni un test de performance.

Vidéo Wan 3.0 : guide complet des entrées, de l’audio, des tarifs et de l’API