API d'images de personnage 3D cohérent : $0.143

Oui—un workflow API pour des images de personnage 3D cohérent peut produire un maître de personnage et cinq candidats de scènes pour moins de quinze cents. Dans notre test du 3 septembre, l'image maître s'est complétée en 32,1 secondes pour 24 crédits. Une deuxième requête Wan 2.7 Image a retourné cinq fichiers de scènes en 59,0 secondes pour 119 crédits. Le total était de 143 crédits, soit $0.143.^[1]

Il y a une limite importante à ce résultat. Le test a enregistré l'état de la tâche, le nombre de sorties, le temps d'exécution et les crédits ; il n'incluait pas une révision visuelle. C'est donc un test mesuré de génération et de coût, non une affirmation que cinq images ont réussi l'évaluation des personnages. Le tutoriel ci-dessous montre comment exécuter le même workflow et calculer le coût par image acceptée après vérification humaine des résultats.

TL;DR

• Le workflow utilise wan2.7-image deux fois : une fois pour un candidat maître de personnage, puis, après approbation, une fois pour une série de cinq scènes connectées.
• Le mode groupe Wan 2.7 Image est activé avec enable_sequential: true ; il élève la limite de n de quatre à douze images dans une seule tâche.^[3]
• La charge API mesurée était 24 crédits pour le maître + 119 crédits pour cinq scènes = 143 crédits ($0.143).^[1]
• Téléchargez l'enregistrement du test daté, qui énumère les deux ID de tâche, les paramètres, les temps d'exécution et les crédits réglés sans dépendre des URL de sortie temporaires.
• Le coût du lot de cinq scènes était $0.0238 par candidat complété. En incluant le maître, le coût effectif est $0,0286 par scène seulement si le maître est approuvé et les cinq scènes passent l'évaluation.
• « Style 3D » signifie des fichiers image plats rendus avec une apparence de dessin animé en 3D. Ce workflow ne crée pas de maille, squelette, rig ou modèle 3D modifiable.
• La cohérence n'est pas garantie. Une image de référence, un contrat d'identité fixe, la génération en groupe et une porte d'approbation réduisent la variation ; aucun n'est un verrou de personnage permanent.

Ce que le test API de personnage cohérent répond

Une API peut-elle préserver le même personnage de style 3D d'une scène à l'autre, et combien coûte chaque image ou chaque lot ? Si une image de référence définit déjà le personnage, il reste à automatiser le processus sans supprimer l'étape de validation humaine. Une tâche terminée ne garantit pas que l'image soit exploitable.

Le test distingue donc trois mesures : l'achèvement de la tâche API, le coût par image candidate et le coût par scène validée. Les deux premières viennent des données de tâche et de facturation ; la troisième exige un examen visuel.

Pourquoi Wan 2.7 Image convient à un ensemble de cinq scènes de personnage

La page de produit officielle de Wan décrit la narration séquentielle avec jusqu'à douze images et la continuité sujet/style.^[2] L'itinéraire reAPI expose cette fonctionnalité directement : définissez enable_sequential à true, définissez n au nombre d'images et interrogez une tâche pour le tableau URL ordonné.^[3]

Cette forme de requête donne à une tâche la référence du personnage, le contrat d'identité, et la liste complète des scènes. Cinq appels text-to-image non liés devraient redécouvrir le personnage à partir de prose cinq fois.

C'est un choix de workflow, non une affirmation de qualité universelle. Wan fournit le contrôle de série en groupe nécessaire pour ce test.

Avant de faire la première requête API

Vous avez besoin de quatre choses :

• une clé reAPI stockée dans REAPI_API_KEY ;
• un personnage fictionnel original dont vous avez le droit d'utiliser ;
• une courte liste de traits visuels qui doivent survivre à chaque scène ;
• un endroit où conserver les fichiers approuvés, car les URLs générées sont temporaires.

Utilisez un personnage original dont vous avez le droit de reproduire, plutôt qu'un personnage célèbre ou le style de studio d'un studio renommé. C'est aussi plus facile à évaluer.

Pour ce test, le contrat de personnage est délibérément concret :

CHARACTER: un renard explorateur anthropomorphe adulte orange chaud original
FACE: museau crème, petite encoche dans l'oreille gauche
CLOTHING: écharpe bleu-vert avec exactement deux rayures blanches
ACCESSORIES: lunettes rondes en laiton sur le front, sacoche cross-body bleu marine
ANCHORS: patch triangle jaune sur la sacoche, deux anneaux de queue noirs, bout de queue crème
DO NOT CHANGE: fourrure orange chaud, museau crème, côté de l'encoche auriculaire, motif d'écharpe,
lunettes, patch de sacoche, marquages de queue, proportions du corps athlétique compact

Les descriptions telles que « mignon », « cinématographique » et « premium » sont trop larges à auditer. Une encoche auriculaire ou une écharpe à deux rayures donne au rédacteur quelque chose d'observable.

Étape 1 : Générer un maître de personnage neutre

Le maître doit expliquer le personnage, pas raconter une histoire. Utilisez une lumière uniforme, un fond simple et des angles qui révèlent le visage, les vêtements, le sac et la queue. Gardez-le au même rapport d'aspect prévu pour l'ensemble de scènes ; en mode piloté par références, Wan suit le dernier rapport d'aspect de l'image d'entrée.^[5]

curl https://reapi.ai/api/v1/images/generations \
  -H "Authorization: Bearer $REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan2.7-image",
    "prompt": "Original stylized 3D cartoon character reference sheet for an adult anthropomorphic fox explorer. The same character shown in a clean front view and two three-quarter views. Identity anchors: a small notch in the left ear, teal scarf with exactly two white stripes, round brass goggles resting on the forehead, navy cross-body satchel with one yellow triangle patch, two dark rings on the tail and a cream tail tip. Warm orange fur, cream muzzle, compact athletic proportions, friendly alert expression. Neutral warm-gray studio background, soft even product lighting, full body visible, no text, no labels, no logo, no second character, no collage borders.",
    "size": "16:9",
    "resolution": "1K",
    "n": 1,
    "watermark": false
  }'

La POST retourne un ID de tâche plutôt que l'image elle-même. Interrogez GET /api/v1/tasks/{id} jusqu'à ce que le statut devienne completed ou failed. L'interrogation ne consomme pas de crédits.^[5]

Dans un workflow de production, arrêtez-vous ici et inspectez le maître avant de générer la série. Rejetez-le si les trois vues ne concordent pas, une ancre est manquante ou une fonctionnalité serait difficile à reconnaître dans une autre pose. Le test mesuré s'est poursuivi sans une porte d'approbation visuelle, donc son maître reste un candidat complété.

Étape 2 : Demander cinq scènes connectées

Prenez la première URL du tableau output.image_urls du maître complété et placez-la dans MASTER_IMAGE_URL. Wan accepte les images de référence HTTPS publiques ; les URLs base64 et data: ne sont pas acceptées par cet itinéraire.^[3]

export MASTER_IMAGE_URL="https://your-temporary-or-hosted-url.example/master.png"

curl https://reapi.ai/api/v1/images/generations \
  -H "Authorization: Bearer $REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<JSON
{
  "model": "wan2.7-image",
  "prompt": "Use the reference image only to preserve the identity of the original adult fox explorer. Create a connected five-image story sequence, one separate scene per output, in the same polished stylized 3D cartoon rendering language. Preserve all identity anchors exactly: left-ear notch, teal scarf with exactly two white stripes, round brass forehead goggles, navy cross-body satchel with one yellow triangle patch, two dark tail rings, cream tail tip, muzzle shape and body proportions. Scene 1: dawn railway platform, medium-wide view, holding one red paper ticket. Scene 2: sunlit workshop, medium view, repairing a small wooden toy airplane. Scene 3: rainy night market, full-body view, carrying one yellow umbrella. Scene 4: snowy wooden footbridge at dusk, three-quarter view, holding a small warm lantern. Scene 5: rooftop at blue hour, rear three-quarter view with face still visible, looking across the city. One fox only in every image. No text, no logo, no wardrobe change, no extra limbs, no duplicate character, and do not combine scenes into a collage.",
  "image_urls": ["$MASTER_IMAGE_URL"],
  "size": "16:9",
  "resolution": "1K",
  "n": 5,
  "enable_sequential": true,
  "watermark": false
}
JSON

Les modes groupe et édition supportent une sortie jusqu'à 2K. L'option 4K du modèle Pro est text-to-image seulement, donc élever cette requête pilotée par références à 4K serait une configuration invalide.^[3]

Étape 3 : Exécuter la porte d'approbation en toute sécurité en Node.js

Enregistrez l'exemple complet ci-dessous comme character-series.mjs et utilisez Node.js 18 ou plus récent. La première exécution génère seulement le maître, imprime et enregistre son ID de tâche, puis s'arrête. Évaluez cette image avant de définir APPROVED_MASTER_URL et d'exécuter le script à nouveau pour le groupe de cinq scènes.

Le script réessaie les défaillances GET transitoires, mais il n'essaie jamais une POST. Si la connexion est interrompue lors de la soumission, le prestataire peut encore avoir reçu la requête ; vérifiez le journal des tâches ou le tableau de bord plutôt que de créer aveuglément une tâche facturée supplémentaire.

import { appendFile } from 'node:fs/promises';

const baseUrl = 'https://reapi.ai';
const apiKey = process.env.REAPI_API_KEY;
const approvedMasterUrl = process.env.APPROVED_MASTER_URL?.trim();
const taskLogUrl = new URL(
  './character-series-task-ids.jsonl',
  import.meta.url,
);

const masterPrompt = process.env.MASTER_PROMPT ??
  'Original stylized 3D cartoon character reference sheet for an adult anthropomorphic fox explorer. The same character shown in a clean front view and two three-quarter views. Identity anchors: a small notch in the left ear, teal scarf with exactly two white stripes, round brass goggles resting on the forehead, navy cross-body satchel with one yellow triangle patch, two dark rings on the tail and a cream tail tip. Warm orange fur, cream muzzle, compact athletic proportions, friendly alert expression. Neutral warm-gray studio background, soft even product lighting, full body visible, no text, no labels, no logo, no second character, no collage borders.';

const groupPrompt = process.env.GROUP_PROMPT ??
  "Use the reference image only to preserve the identity of the original adult fox explorer. Create a connected five-image story sequence, one separate scene per output, in the same polished stylized 3D cartoon rendering language. Preserve all identity anchors exactly: left-ear notch, teal scarf with exactly two white stripes, round brass forehead goggles, navy cross-body satchel with one yellow triangle patch, two dark tail rings, cream tail tip, muzzle shape and body proportions. Scene 1: dawn railway platform, medium-wide view, holding one red paper ticket. Scene 2: sunlit workshop, medium view, repairing a small wooden toy airplane. Scene 3: rainy night market, full-body view, carrying one yellow umbrella. Scene 4: snowy wooden footbridge at dusk, three-quarter view, holding a small warm lantern. Scene 5: rooftop at blue hour, rear three-quarter view with face still visible, looking across the city. One fox only in every image. No text, no logo, no wardrobe change, no extra limbs, no duplicate character, and do not combine scenes into a collage.";

if (!apiKey) {
  throw new Error('Set REAPI_API_KEY before running this script.');
}

for (const [name, value] of [
  ['MASTER_PROMPT', masterPrompt],
  ['GROUP_PROMPT', groupPrompt],
]) {
  if (!value.trim()) throw new Error(`${name} cannot be empty.`);
}

const headers = {
  Authorization: `Bearer ${apiKey}`,
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function readJson(response) {
  const text = await response.text();
  if (!text) return {};
  try {
    return JSON.parse(text);
  } catch {
    return { raw: text };
  }
}

async function submitGeneration(body) {
  let response;

  try {
    response = await fetch(`${baseUrl}/api/v1/images/generations`, {
      method: 'POST',
      headers,
      body: JSON.stringify(body),
    });
  } catch (error) {
    const detail = error instanceof Error ? error.message : String(error);
    throw new Error(
      `POST outcome is uncertain; do not submit it again automatically. ${detail}`,
    );
  }

  const result = await readJson(response);
  if (!response.ok) {
    throw new Error(`${response.status}: ${JSON.stringify(result)}`);
  }
  if (!result.id) {
    throw new Error(
      'POST returned no task ID; do not resubmit automatically until checked.',
    );
  }
  return result;
}

function retryDelayMs(response, attempt) {
  const retryAfter = response?.headers.get('retry-after');
  if (retryAfter) {
    const seconds = Number(retryAfter);
    if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);

    const retryAt = Date.parse(retryAfter);
    if (Number.isFinite(retryAt)) return Math.max(0, retryAt - Date.now());
  }
  return Math.min(1000 * (2 ** Math.min(attempt, 5)), 30000);
}

async function getTaskWithRetry(id, attempt) {
  let response;

  try {
    response = await fetch(`${baseUrl}/api/v1/tasks/${id}`, { headers });
  } catch (error) {
    const delay = retryDelayMs(null, attempt);
    console.warn(`Task GET failed; retrying in ${delay}ms.`);
    await sleep(delay);
    return null;
  }

  if (response.status === 429 || response.status >= 500) {
    const delay = retryDelayMs(response, attempt);
    await response.text();
    console.warn(`Task GET returned ${response.status}; retrying in ${delay}ms.`);
    await sleep(delay);
    return null;
  }

  const task = await readJson(response);
  if (!response.ok) {
    throw new Error(`${response.status}: ${JSON.stringify(task)}`);
  }
  return task;
}

async function waitForTask(id, timeoutMs = 10 * 60 * 1000) {
  const deadline = Date.now() + timeoutMs;
  let transientAttempt = 0;

  while (Date.now() < deadline) {
    const task = await getTaskWithRetry(id, transientAttempt);
    if (!task) {
      transientAttempt += 1;
      continue;
    }
    transientAttempt = 0;

    if (task.status === 'completed') return task;
    if (task.status === 'failed') {
      console.error(JSON.stringify({
        taskId: id,
        status: task.status,
        usageCredits: task.usage?.credits ?? null,
        error: task.error ?? null,
      }, null, 2));
      throw new Error(`Task ${id} failed; see the record above.`);
    }

    await sleep(5000);
  }

  throw new Error(
    `Polling timed out for ${id}. The task was not cancelled; resume GET polling instead of submitting another POST.`,
  );
}

async function recordSubmission(stage, taskId) {
  const record = {
    stage,
    taskId,
    submittedAt: new Date().toISOString(),
  };
  console.log(`Submitted ${stage}: ${taskId}`);

  try {
    await appendFile(taskLogUrl, `${JSON.stringify(record)}\n`, 'utf8');
  } catch (error) {
    console.warn(`Could not write ${taskLogUrl.pathname}; keep task ID ${taskId}.`);
  }
}

function requirePublicHttpsUrl(value) {
  let parsed;
  try {
    parsed = new URL(value);
  } catch {
    throw new Error('APPROVED_MASTER_URL must be a valid public HTTPS URL.');
  }
  if (parsed.protocol !== 'https:') {
    throw new Error('APPROVED_MASTER_URL must use HTTPS.');
  }
}

async function main() {
  if (!approvedMasterUrl) {
    const submission = await submitGeneration({
      model: 'wan2.7-image',
      prompt: masterPrompt,
      size: '16:9',
      resolution: '1K',
      n: 1,
      watermark: false,
    });
    await recordSubmission('character_master', submission.id);

    const task = await waitForTask(submission.id);
    const masterUrl = task.output?.image_urls?.[0];
    if (!masterUrl) throw new Error('Master task returned no image URL.');

    console.log(JSON.stringify({
      nextStep: 'Review this master. Rerun only after setting APPROVED_MASTER_URL.',
      masterTaskId: task.id,
      usageCredits: task.usage?.credits ?? null,
      masterUrl,
    }, null, 2));
    return;
  }

  requirePublicHttpsUrl(approvedMasterUrl);
  const submission = await submitGeneration({
    model: 'wan2.7-image',
    prompt: groupPrompt,
    image_urls: [approvedMasterUrl],
    size: '16:9',
    resolution: '1K',
    n: 5,
    enable_sequential: true,
    watermark: false,
  });
  await recordSubmission('five_scene_group', submission.id);

  const task = await waitForTask(submission.id);
  const sceneUrls = task.output?.image_urls ?? [];

  console.log(JSON.stringify({
    groupTaskId: task.id,
    usageCredits: task.usage?.credits ?? null,
    returnedSceneCount: sceneUrls.length,
    sceneUrls,
  }, null, 2));
}

main().catch((error) => {
  console.error(error instanceof Error ? error.message : error);
  process.exitCode = 1;
});

Exécutez node character-series.mjs en premier. Après révision du maître retourné, relancez avec APPROVED_MASTER_URL="https://..." node character-series.mjs. Le script écrit les ID de tâche dans character-series-task-ids.jsonl ; ses résultats de stade incluent les usageCredits réglés. Vous pouvez remplacer soit le prompt incorporé avec MASTER_PROMPT ou GROUP_PROMPT, mais une substitution vide est rejetée.

Dans n8n, conservez la même frontière d'approbation : la branche maître devrait se terminer à une étape de révision humaine, et seule une URL approuvée devrait entrer dans la branche de génération de groupe.

Ce que l'exécution API mesurée a retourné

Les deux requêtes se sont complétées comme suit :^[1]

Ce sont deux temps de tâche observés, non un benchmark de latence. Ils ne disent rien sur la performance p95, une autre région, un prompt différent ou une capacité future. Les URLs de sortie sont également omises car elles sont temporaires.

Plus important encore, « fichiers retournés : 5 » signifie cinq candidats complétés. Cela ne prouve pas que chaque sortie dépeint le renard correctement, cartographie la scène prévue, ou évite les défauts visuels.

Comment réviser la cohérence des personnages scène par scène

Ouvrez le maître à côté de chaque scène. Ne jugez pas à partir de petites vignettes ; inspectez le visage, la tenue, les accessoires, la silhouette et l'action demandée à un zoom utile.

Marquez une ancre comme N/A quand le cadre la cache véritablement. N'accordez pas un succès pour un trait caché, mais ne l'appelez pas une contradiction non plus. Une image est acceptée seulement quand chaque ancre d'identité visible est correcte, la scène demandée est présente et il n'y a pas de défaut structurel majeur.

Cette rubrique est intentionnellement simple. Le scoring de vision automatisé peut aider à trier un grand lot, mais il ne devrait pas remplacer silencieusement la décision de lancement pour un nouveau personnage.

Calculer le coût par image complétée et acceptée

Le taux actuel de Wan 2.7 Image est $0.0238 par image Standard générée sur reAPI. Les crédits sont réglés une seule fois au total de la tâche et arrondis à un crédit entier : ceil(\$0.0238 × 1 × 1,000) = 24 pour le maître, tandis que ceil(\$0.0238 × 5 × 1,000) = 119 pour le groupe.^[3][4]

Pour cette exécution :

coût candidat groupe = $0.119 / 5 = $0.0238
coût projet          = $0.024 + $0.119 = $0.143
coût image acceptée  = $0.143 / nombre de scènes acceptées

Si aucun ne passe, le projet n'a produit aucune image acceptée, donc un chiffre par image acceptée est indéfini plutôt que zéro. Les $0.143 couvrent également la génération seulement. Le stockage, l'orchestration, l'évaluation humaine et l'animation ultérieure relèvent d'un budget de production complet.

Les tarifs changent. Les chiffres ci-dessus ont été vérifiés et testés le 3 septembre 2026 ; utilisez la page de modèle Wan 2.7 Image en direct avant de placer un prix dans votre propre produit.

Réparer la plus petite partie défaillante

Si le maître est mauvais, arrêtez-vous et régénérez-le. Payer pour une série de cinq images basée sur une faible référence multiplie seulement le problème.

Si une scène manque son accessoire mais le personnage reste stable, essayez un simple remplacement piloté par référence n: 1 avec un prompt de scène plus court. Au taux testé, cela ajoute environ 24 crédits. Si plusieurs images redesignent le personnage, révisez le maître ou supprimez les instructions conflictuelles, puis relancez le groupe connecté.

La documentation actuelle du modèle de Wan dit que les requêtes défaillantes et rejetées ne sont pas facturées. Néanmoins, lisez usage.credits sur chaque tâche terminale : l'API Tasks canonique permet une valeur positive sur une tâche défaillante quand une politique spécifique au modèle maintient une charge post-génération.^[3][5] Une image complétée que votre équipe rejette créativement reste facturée, c'est pourquoi le coût d'image acceptée est la métrique de production utile.

Une fois qu'une scène passe, conservez-la avec son ID de tâche, sa version de prompt, sa version de référence et son résultat d'évaluation. Les URLs générées expirent, alors déplacez les actifs approuvés dans un stockage que vous contrôlez dès que pratique.^[3]

Erreurs courantes des débutants

Générer chaque scène à partir du texte. Répéter une description détaillée ne rend pas cinq échantillons indépendants partageant une identité. Réutilisez les pixels approuvés.

Changer le contrat de personnage dans les prompts de scène. « Ajouter un manteau d'hiver » peut être un changement d'histoire raisonnable, mais il supprime une ancre de continuité facile. Testez d'abord l'identité stable ; introduisez les changements de garde-robe délibérés plus tard.

Fournir trop de références. Les références qui ne s'accordent pas sur le visage, la queue ou les vêtements donnent au modèle plusieurs réponses valides. Commencez avec un maître approuvé unique.

Appeler tous les fichiers complétés utilisables. L'achèvement est un état système. L'approbation créative est une décision d'évaluation.

Publier seulement le prix du titre. Indiquez si le chiffre couvre le maître, les tentatives, les sorties complétées rejetées créativement, le stockage et l'évaluation humaine.

FAQ

Cette API génère-t-elle un vrai modèle 3D de caractère ?

Non. Elle retourne des fichiers image avec une apparence 3D stylisée. Elle ne retourne pas de maille, rig, paquet de texture, squelette ou scène modifiable.

Wan 2.7 garantit-il le même personnage dans chaque image ?

Non. Le mode groupe et une image de référence donnent au modèle des signaux de continuité plus forts, mais ils ne créent pas un ID de personnage permanent. Chaque scène nécessite toujours une révision.

Combien coûte le lot de cinq scènes ?

La tâche de groupe a utilisé 119 crédits, soit $0.119, et a retourné cinq candidats complétés. Le maître généré séparément a utilisé 24 crédits, portant le total du test à $0.143.^[1]

Pourquoi le coût effectif n'est-il pas simplement $0.0238 par image ?

$0.0238 est le coût du groupe par candidat complété. Un projet a aussi besoin d'un maître, et certains candidats peuvent échouer l'examen visuel. Divisez la dépense totale du projet par le nombre de scènes acceptées pour obtenir le chiffre utile.

Puis-je utiliser ma propre image de référence de personnage ?

Oui, si vous la possédez ou avez la permission de l'utiliser et qu'elle est disponible via une URL HTTPS publique. Wan 2.7 Image accepte jusqu'à neuf images de référence, bien qu'un maître clair unique soit un point de départ sensé.^[3]

Dois-je utiliser la même seed pour chaque scène ?

Wan expose une seed, mais ce n'est pas un verrou d'identité. Pour une série connectée, l'image de référence approuvée et la requête de groupe sont plus importantes. Une seed répétée avec des entrées modifiées ne garantit pas le même visage ou les mêmes accessoires.

Puis-je générer plus de cinq scènes en une requête ?

Oui. Avec enable_sequential: true, n peut aller jusqu'à douze. Commencez avec un ensemble plus petit car l'évaluation et la complexité du prompt augmentent avec la séquence.

Comment transformer les images acceptées en vidéo ?

Utilisez chaque scène approuvée comme cadre de démarrage contrôlé pour un modèle d'image vers vidéo. Le workflow de personnage GPT Image 2 + Seedance 2.0 explique l'étape d'animation séparée ; la garder séparée empêche les défaillances de mouvement de forcer une redésign du personnage.

Enregistrer ce que vous expédieriez réellement

L'enregistrement API contient un maître, un groupe de cinq images, six fichiers retournés, et une charge totale de $0.143. Il ne contient pas un taux d'acceptation créative car l'évaluation visuelle était en dehors de ce test.

Gardez l'achèvement, le coût et l'acceptation humaine comme champs séparés. Après application de la rubrique, divisez le coût total du projet par le nombre de scènes que vous expédieriez réellement.

Pour le schéma de requête complet, les limites et le comportement de facturation actuel, utilisez la documentation de l'API Wan 2.7 Image.

Références

1. reAPI. Enregistrement de test de série de personnages Wan 2.7 Image 3 septembre 2026. Tâche maître task_01a065451919736985878cfcbd2eb8a8 ; tâche de groupe task_01a06545f23474bca896f6b98ee252bc.
2. Alibaba Wan. Page de produit officielle Wan — Édition Multi-Image et Narration Séquentielle. Consulté le 3 septembre 2026. wan.video
3. reAPI. API Wan 2.7 Image — mode groupe, entrées de référence, limites de résolution, réponse de tâche et erreurs. Consulté le 3 septembre 2026. reapi.ai/docs/wan-2-7-image
4. reAPI. Page de modèle Wan 2.7 Image en direct et estimateur de prix. Consulté le 3 septembre 2026. reapi.ai/models/wan-2-7-image
5. reAPI. API des tâches — comportement de statut asynchrone et d'interrogation. Consulté le 3 septembre 2026. reapi.ai/docs/api/tasks

Lectures complémentaires

• reAPI. GPT Image 2 + Seedance 2.0 : Un Workflow de Cohérence des Personnages. Lire le workflow vidéo
• reAPI. Coût de Génération d'Image IA vs Vidéo : 2–9x Plus Par Frame. Lire l'analyse des coûts