Combien coûte une vidéo IA par jour ? Budget API pour 30 jours

Pour la configuration testée ici, un seul clip par jour pendant 30 jours coûte $2,52 en frais de génération. Chaque tentative est un clip de 5 secondes, 480p, 9:16 avec seedance-2.0-mini. Le test unique a consommé 84 crédits reAPI, soit $0,084, et s'est exécuté en 107,2 secondes, renvoyant une URL vidéo.^[6]

C'est la réponse simple, mais ce n'est pas encore un budget de production. Une tâche API complète n'est pas nécessairement un clip que vous publierez. Si l'examen rejette la moitié de vos tentatives complétées, le budget de génération double à $5,04 par mois. Le stockage, la planification, l'édition et l'examen humain sortent de ce chiffre.

Ce guide calcule le nombre honnête et construit un exemple monoprocédé qui s'arrête pour un rapprochement manuel au lieu de deviner si une requête POST incertaine doit être répétée.

TL;DR

• Une tâche testée de 5 secondes, 480p, 9:16 Seedance 2.0 Mini a utilisé 84 crédits = $0,084. Trente tentatives identiques complétées coûteraient $2,52.
• Budgétiser par tentatives complétées par vidéo acceptée, pas seulement par publications planifiées. Avec 1,5 tentatives par clip accepté, le budget de génération sur 30 jours est $3,78 ; avec deux tentatives, c'est $5,04.
• Les nouveaux comptes éligibles peuvent recevoir des crédits de test promotionnels, mais la page de tarification publique ne promet ni un montant fixe ni une réinitialisation quotidienne.^[3] Traitez-les comme une piste de prototype, pas une capacité récurrente.
• Enregistrez l'ID de tâche immédiatement. Chaque POST répété accepté crée une tâche séparée et une réservation de crédit ; chaque tâche complète règle son propre usage. Idempotency-Key enregistre une valeur de traçage mais ne déduplique pas les requêtes vidéo.^[4]
• Interrogez la tâche avec GET environ toutes les cinq secondes, archivez le fichier retourné dans le stockage que vous contrôlez, et mainteniez la publication derrière une étape d'examen manuel.^[5]
• Le résultat de 107,2 secondes est un test unique, pas une affirmation sur la vitesse moyenne, la disponibilité ou la qualité visuelle.

La vraie question vidéo quotidienne que les gens posent

Avez-vous besoin d'une vraie API REST capable de créer un ou deux courts clips verticaux chaque jour, de retourner une URL HTTPS publique et de s'adapter à un flux de publication automatisé ? Pour un prototype de 4 à 5 secondes de 9:16, le coût n'est que la moitié de la question. La récupération importe dès que le prototype devient une planification : le flux de travail a besoin d'un état durable et d'une politique de retry délibérée avant d'avoir besoin d'un prompt intelligent.

Une exécution de 107 secondes, avec une conclusion étroite

Le test a utilisé la configuration reAPI actuelle la moins chère que nous ayons trouvée qui accepte un prompt texte et prend explicitement en charge à la fois 9:16 et une durée de 4 à 5 secondes : Seedance 2.0 Mini à 480p.^[1] La documentation du modèle autorise 480p ou 720p, 9:16 en sortie, et des durées de 4 à 15 secondes.^[2]

Sortie archivée de ce test exact : cinq secondes, 480p, 9:16, audio désactivé et filigrane désactivé. L'achèvement technique et la facturation ont été vérifiés ; l'acceptabilité créative n'a pas été notée.

Le taux actuel 480p est $0,016625 par seconde facturable.^[1] reAPI facture un crédit comme $0,001 et arrondit une tâche au crédit entier suivant.^[2] Pour la requête de test :

ceil($0,016625 × 5 secondes × 1 000 crédits par dollar)
= ceil(83,125 crédits)
= 84 crédits
= $0,084

Un POST accepté réserve des crédits pour sa propre tâche. La réservation se règle quand cette tâche atteint un état terminal : lisez status avec usage.credits plutôt que de traiter l'admission comme la facture finale. Seedance 2.0 Mini rembourse une génération échouée selon sa politique de facturation documentée.^[2][5]

Ce seul résultat confirme le chemin de requête, le statut d'achèvement, l'URL retournée et les frais. Il ne peut pas établir un temps de rendu typique, un taux de succès, un taux d'acceptabilité ou une note de qualité visuelle.

Téléchargez l'enregistrement du test. Il contient les paramètres de requête, l'ID de tâche, le temps écoulé, le statut terminal et les crédits réglés. L'URL de tâche temporaire est omise ; l'enregistrement pointe vers la même vidéo dans le stockage CDN reAPI permanent.

Les prix peuvent changer. Vérifiez la page du modèle Seedance 2.0 Mini en direct avant de transformer ces chiffres en devis client ou limite de dépenses ferme.

Un budget de 30 jours commence par les tentatives complétées

Le calcul mensuel minimum est direct :

30 jours × 84 crédits = 2 520 crédits = $2,52

Cela suppose qu'une tentative complète devient une vidéo acceptée chaque jour. Une formule de planification plus utile est :

coût de génération mensuel
= jours × vidéos par jour × tentatives complétées par vidéo acceptée × coût par tentative

Pour un clip accepté par jour au taux testé :

"1,5 tentative" est une moyenne mensuelle, pas une demi-requête : 15 clips pourraient passer à la première fois et 15 en auraient besoin d'une de rechange. Comptez les générations complétées rejetées pour mouvement incorrect, composition ou inadéquation avec le brief.

La résolution et la durée changent également le coût unitaire de départ. Les chiffres suivants appliquent le taux documenté actuel et la formule de facturation ; seule la ligne de 5 secondes à 480p a été exécutée comme test pour cet article.

Ce sont des coûts de génération, pas des coûts de contenu totaux. Ils excluent l'écriture de prompts, les ressources source, l'édition, les sous-titres, les licences musicales, le stockage d'objets, l'automatisation d'hébergement, les frais d'API de plateforme et le temps consacré à l'approbation de chaque clip.

Pourquoi les crédits gratuits ne sont pas une capacité durable

Les crédits gratuits peuvent prouver que l'authentification, les champs de requête, l'interrogation et le téléchargement fonctionnent. Sans une quantité connue et une règle de renouvellement, ils ne peuvent pas soutenir une promesse récurrente.

Les nouveaux comptes éligibles peuvent recevoir des crédits de test promotionnels ; la disponibilité et le montant sont affichés à l'inscription ou dans le tableau de bord. La page de tarification publique ne promet ni un montant fixe ni une réinitialisation quotidienne.^[3] Cela rend la subvention inadéquate comme capacité mensuelle fiable. La même règle s'applique aux allocations d'application grand public : sans accès API documenté, limites et comportement de réinitialisation, les crédits UI ne sont pas un budget API.

Utilisez le solde gratuit pour tester un seul chemin étroit. Puis budgétisez le flux de travail en état stable au taux payant et traitez tout crédit gratuit comme une réduction temporaire. Cela rend le projet viable après le lancement plutôt que seulement le jour de la démo.

Avant d'automatiser la première requête

Pour une configuration adaptée aux débutants, préparez ces éléments :

• Un compte reAPI et une clé API côté serveur. Ne mettez jamais la clé dans le code du navigateur, un référentiel public ou un flux de travail téléchargeable.
• Un prompt qui décrit un seul court plan. Cinq secondes ne suffisent pas pour une histoire multi-scènes.
• Un planificateur tel que cron, GitHub Actions, n8n ou un worker de file d'attente.
• Un endroit durable pour enregistrer la clé du travail quotidien et l'ID de tâche reAPI.
• Le stockage que vous contrôlez pour les fichiers complétés.
• Une personne qui examinera le clip avant sa publication.

Les exemples ci-dessous utilisent les dates UTC. Si le calendrier de contenu suit un fuseau horaire local, calculez la date du travail dans ce fuseau horaire de manière cohérente. Sinon, un travail près de minuit peut recevoir la clé du mauvais jour.

Soumettez une vidéo 9:16 avec cURL

Commencez par définir la clé API dans votre shell :

export REAPI_API_KEY='replace-with-your-server-side-key'

Soumettez une tâche et enregistrez la réponse avant de faire autre chose :

curl --fail-with-body --silent --show-error \
  --request POST 'https://reapi.ai/api/v1/videos/generations' \
  --header "Authorization: Bearer $REAPI_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "seedance-2.0-mini",
    "prompt": "A handmade ceramic cup beside an open notebook, soft morning window light, one slow push-in shot, natural motion, no text",
    "resolution": "480p",
    "aspect_ratio": "9:16",
    "duration": 5,
    "generate_audio": false,
    "watermark": false
  }' \
  --output submit.json

Ouvrez submit.json et copiez son id. Si vous avez jq, cela l'extrait :

TASK_ID="$(jq -r '.id' submit.json)"
test -n "$TASK_ID" && test "$TASK_ID" != 'null' || exit 1
printf '%s\n' "$TASK_ID" > task-id.txt

L'interrogation utilise GET, qui ne consomme pas de crédits :^[5]

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $REAPI_API_KEY" \
  "https://reapi.ai/api/v1/tasks/$TASK_ID" \
  --output task.json
jq '{id, status, usage, output, error}' task.json

Exécutez à nouveau la dernière commande après environ cinq secondes pendant que le statut est processing. Les états terminaux documentés sont completed et failed. Ne resoumettez pas le POST simplement parce que la première interrogation n'a pas de vidéo.

Construisez un flux de travail quotidien plus sûr dans Node.js

L'exemple cURL prouve les champs. Le script ci-dessous est une garde monoprocédé au plus une fois, pas une file d'attente d'exactement une fois. Il enregistre l'intention avant la soumission, enregistre l'ID de tâche dès que la réponse arrive, limite chaque appel réseau, archive localement et s'arrête pour rapprochement manuel chaque fois qu'il ne peut pas savoir si un POST a été accepté. Il utilise Node.js 20 ou ultérieur et aucun paquet externe. N'exécutez pas deux copies contre le même fichier JSON.

Enregistrez-le en tant que daily-video.mjs :

import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
import { join } from 'node:path';

const API_BASE = 'https://reapi.ai/api/v1';
const STORE_PATH = './daily-video-jobs.json';
const OUTPUT_DIR = './daily-video-output';
const POLL_MS = 5_000;
const POLL_LIMIT_MS = 30 * 60 * 1_000;
const POST_TIMEOUT_MS = 30_000;
const GET_TIMEOUT_MS = 20_000;
const DOWNLOAD_TIMEOUT_MS = 120_000;
const apiKey = process.env.REAPI_API_KEY;

if (!apiKey) {
  throw new Error('Set REAPI_API_KEY in the server environment.');
}

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

function retryAfterMs(value) {
  if (!value) return POLL_MS;
  const seconds = Number(value);
  if (Number.isFinite(seconds)) return Math.max(seconds * 1_000, 0);
  const date = Date.parse(value);
  return Number.isNaN(date) ? POLL_MS : Math.max(date - Date.now(), 0);
}

async function loadJobs() {
  try {
    return JSON.parse(await readFile(STORE_PATH, 'utf8'));
  } catch (error) {
    if (error.code === 'ENOENT') return {};
    throw error;
  }
}

async function saveJobs(jobs) {
  const temporaryPath = `${STORE_PATH}.tmp`;
  await writeFile(temporaryPath, `${JSON.stringify(jobs, null, 2)}\n`);
  await rename(temporaryPath, STORE_PATH);
}

async function requestJson(url, options) {
  const response = await fetch(url, options);
  const body = await response.text();
  let data;

  try {
    data = JSON.parse(body);
  } catch {
    data = { raw: body };
  }

  if (!response.ok) {
    const error = new Error(`HTTP ${response.status}: ${body.slice(0, 300)}`);
    error.status = response.status;
    error.retryAfterMs = retryAfterMs(response.headers.get('retry-after'));
    error.requestId = data?.error?.request_id ?? null;
    throw error;
  }

  return data;
}

async function archiveVideo(url, jobKey) {
  const response = await fetch(url, {
    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
  });
  if (!response.ok) {
    throw new Error(`Video download failed with HTTP ${response.status}.`);
  }

  await mkdir(OUTPUT_DIR, { recursive: true });
  const safeName = jobKey.replace(/[^a-z0-9-]/gi, '_');
  const outputPath = join(OUTPUT_DIR, `${safeName}.mp4`);
  const bytes = Buffer.from(await response.arrayBuffer());
  await writeFile(outputPath, bytes);
  return outputPath;
}

async function main() {
  const utcDate = new Date().toISOString().slice(0, 10);
  const jobKey = `daily-short:${utcDate}`;
  const jobs = await loadJobs();

  if (!jobs[jobKey]) {
    // Persist intent before POST. A crash after this point must not cause an
    // automatic second submission on the next scheduler run.
    jobs[jobKey] = {
      state: 'submitting',
      createdAt: new Date().toISOString(),
      idempotencyKey: jobKey,
    };
    await saveJobs(jobs);

    try {
      const task = await requestJson(`${API_BASE}/videos/generations`, {
        method: 'POST',
        headers: {
          Authorization: `Bearer ${apiKey}`,
          'Content-Type': 'application/json',
          // Trace-only on reAPI. This header does not deduplicate the POST.
          'Idempotency-Key': jobKey,
        },
        signal: AbortSignal.timeout(POST_TIMEOUT_MS),
        body: JSON.stringify({
          model: 'seedance-2.0-mini',
          prompt:
            'A handmade ceramic cup beside an open notebook, soft morning ' +
            'window light, one slow push-in shot, natural motion, no text',
          resolution: '480p',
          aspect_ratio: '9:16',
          duration: 5,
          generate_audio: false,
          watermark: false,
        }),
      });

      if (!task.id) throw new Error('Submission returned no task ID.');

      jobs[jobKey] = {
        ...jobs[jobKey],
        state: 'processing',
        taskId: task.id,
        submittedAt: new Date().toISOString(),
      };
      await saveJobs(jobs);
    } catch (error) {
      const receivedHttpResponse = Number.isInteger(error.status);
      jobs[jobKey] = {
        ...jobs[jobKey],
        state: receivedHttpResponse ? 'submit_rejected' : 'submit_uncertain',
        error: error instanceof Error ? error.message : String(error),
        requestId: error.requestId ?? null,
      };
      await saveJobs(jobs);
      throw new Error(
        receivedHttpResponse
          ? `Submission for ${jobKey} was rejected. Review the HTTP error ` +
              'before creating a separately counted retry.'
          : `Submission for ${jobKey} is uncertain. Use ${jobKey} and the ` +
              'saved request ID, if present, to inspect logs or the dashboard. ' +
              'Do not submit again until a person reconciles the result.',
      );
    }
  }

  let job = jobs[jobKey];
  if (job.state === 'pending_review' || job.state === 'approved') {
    console.log(`${jobKey} already has an archived output: ${job.archivePath}`);
    return;
  }
  if (job.state === 'completed_no_output') {
    throw new Error(
      `${jobKey} completed without a video URL. Inspect ${job.taskId}; do not POST again.`,
    );
  }
  if (job.state === 'failed') {
    throw new Error(
      `${jobKey} failed. Review its settled usage before creating a new retry key.`,
    );
  }
  if (!job.taskId) {
    throw new Error(
      `${jobKey} has no task ID. Resolve ${job.state} manually; do not resubmit.`,
    );
  }

  if (!job.outputUrl) {
    const deadline = Date.now() + POLL_LIMIT_MS;
    let task;

    while (Date.now() < deadline) {
      try {
        task = await requestJson(`${API_BASE}/tasks/${job.taskId}`, {
          headers: { Authorization: `Bearer ${apiKey}` },
          signal: AbortSignal.timeout(GET_TIMEOUT_MS),
        });
      } catch (error) {
        const remainingMs = Math.max(deadline - Date.now(), 0);
        if (error.status === 429) {
          const waitMs = Math.min(error.retryAfterMs ?? POLL_MS, remainingMs);
          console.warn(`Rate limited; waiting ${waitMs} ms before another GET.`);
          if (waitMs > 0) await sleep(waitMs);
          continue;
        }
        const networkError = !Number.isInteger(error.status);
        const serverError = error.status >= 500 && error.status < 600;
        if (!networkError && !serverError) {
          throw error;
        }
        const waitMs = Math.min(POLL_MS, remainingMs);
        console.warn('Network or server error; retrying the same task GET.');
        if (waitMs > 0) await sleep(waitMs);
        continue;
      }

      if (task.status === 'completed' || task.status === 'failed') break;
      if (task.status !== 'processing') {
        throw new Error(`Unexpected task status: ${task.status}`);
      }
      await sleep(Math.min(POLL_MS, Math.max(deadline - Date.now(), 0)));
    }

    if (!task || (task.status !== 'completed' && task.status !== 'failed')) {
      jobs[jobKey] = { ...job, state: 'poll_timeout' };
      await saveJobs(jobs);
      throw new Error(
        'Polling timed out. The task may still be running; do not POST again.',
      );
    }

    if (task.status === 'failed') {
      jobs[jobKey] = {
        ...job,
        state: 'failed',
        usageCredits: task.usage?.credits ?? null,
        taskError: task.error ?? null,
      };
      await saveJobs(jobs);
      throw new Error(
        'Generation failed. Review settled usage before scheduling a retry.',
      );
    }

    const outputUrl = task.output?.video_urls?.[0];
    if (!outputUrl) {
      jobs[jobKey] = {
        ...job,
        state: 'completed_no_output',
        usageCredits: task.usage?.credits ?? null,
        completedAt: new Date().toISOString(),
      };
      await saveJobs(jobs);
      throw new Error('Completed task returned no video URL; do not POST again.');
    }

    // Save completion before downloading so storage trouble cannot trigger POST.
    jobs[jobKey] = {
      ...job,
      state: 'completed',
      outputUrl,
      usageCredits: task.usage?.credits ?? null,
      completedAt: new Date().toISOString(),
    };
    await saveJobs(jobs);
    job = jobs[jobKey];
  }

  try {
    const archivePath = await archiveVideo(job.outputUrl, jobKey);
    jobs[jobKey] = {
      ...job,
      state: 'pending_review',
      archivePath,
      archiveError: null,
    };
    await saveJobs(jobs);
    console.log(`Saved ${archivePath}. Review it before publishing.`);
  } catch (error) {
    jobs[jobKey] = {
      ...job,
      state: 'archive_failed',
      archiveError: error instanceof Error ? error.message : String(error),
    };
    await saveJobs(jobs);
    throw new Error(
      'Archiving failed. The task remains completed; rerun to retry only the download.',
    );
  }
}

await main();

Exécutez-le une fois :

node daily-video.mjs

Le fichier JSON peut redémarrer sur une machine, mais ce n'est pas un verrouillage multiprocédé. En production, insérez une ligne de base de données avec une job_key unique, puis laissez seulement le worker qui gagne une déclaration atomique la déplacer de scheduled à submitting. Une déclaration de base de données empêche deux workers actifs de soumettre ensemble. Elle ne peut pas rendre une écriture de base de données et une requête API externe atomiques.

Ce qui se passe après un crash

L'action suivante sûre dépend du dernier état qui a atteint le stockage :

L'état incertain est l'écart inévitable. Une connexion peut échouer après que reAPI accepte une requête mais avant que l'ID de tâche ne soit atteint dans votre processus. Le script envoie la clé du travail quotidien en tant que Idempotency-Key pour que les logs puissent corréler la tentative, mais reAPI enregistre seulement cet en-tête pour le traçage ; il ne déduplique pas.^[4] Un deuxième POST accepté crée une autre tâche et réservation, et une deuxième complétude règle une autre charge. Si les logs ou le tableau de bord ne peuvent pas résoudre l'ambiguïté, l'opérateur doit choisir entre ignorer le clip du jour et risquer une duplication. Il n'y a pas de réponse honnête d'exactement une fois automatique dans cet exemple.

La recherche de tâche est différente. Réessayer GET ne crée ni génération ni n'utilise de crédits. L'exemple limite chaque requête, s'arrête sur les erreurs 4xx déterministes, honore Retry-After sur 429, et réessaye les erreurs réseau ou les réponses 5xx dans la fenêtre d'interrogation de 30 minutes. Un intervalle de cinq secondes évite également de relire à plusieurs reprises le cache en vol de cinq secondes du point de terminaison de tâche.^[5]

Examen et stockage du clip avant la publication

Le travail de l'API se termine quand il livre le fichier. Un clip techniquement complété peut toujours mal représenter le brief ou échouer sur un flux social. Examinez chaque résultat pour :

• le sujet prévu, l'action et le mouvement de la caméra ;
• les objets, mains, visages, emballages ou logos déformés ;
• les mots non désirés ou les réclamations de produits inventées ;
• le scintillement, les changements de scène soudains ou les cultures dangereuses ;
• les droits sur le prompt, les matériaux de référence, la musique et les ressemblances ;
• les exigences techniques et de divulgation actuelles de la plate-forme de destination.

Marquez un clip approved uniquement après cette vérification. S'il échoue, créez une retry délibérément comptée, comme daily-short:2026-09-03:retry-1 ; n'effacez jamais la première tentative du grand livre des coûts.

Déplacez le MP4 avant de l'ajouter à la file d'attente de publication de demain. L'URL de sortie de reAPI est un point de transfert, pas une bibliothèque média permanente.^[5] Le tutoriel enregistre localement ; utilisez S3, R2 ou votre magasin d'objets normal sur un déploiement éphémère.

Ce que le chiffre $2,52 ne promet pas

Le chiffre mensuel est un scénario transparent, pas une garantie. Il suppose le même prix, durée, résolution et nombre de tentatives complétées pendant 30 jours. Il n'établit pas :

• la file d'attente normale ou le temps de génération à partir d'une observation de 107,2 secondes ;
• la disponibilité du service ou un taux d'échec ;
• un taux d'acceptabilité visuelle pour vos prompts ;
• les dimensions de sortie exactes au-delà des paramètres 480p et 9:16 demandés ;
• la publication réussie sur toute plate-forme sociale ;
• la disponibilité des prix ou des crédits gratuits futurs.

Gardez ces variables visibles dans le tableau de bord. Au minimum, enregistrez job_key, task_id, les paramètres de requête, le statut final, usage.credits, la décision d'examen et l'URL d'objet archivé. Après 30 jours, remplacez le nombre de tentatives par vidéo supposé par votre taux d'acceptation mesuré.

Foire aux questions

Combien coûte une vidéo IA verticale de 5 secondes par jour ?

La configuration testée Seedance 2.0 Mini a coûté 84 crédits, ou $0,084, pour une tâche complète de cinq secondes 480p 9:16. À une tentative complète par jour, 30 jours coûtent $2,52. Vérifiez le prix du modèle en direct avant de budgétiser un mois futur.

Et si je veux deux vidéos par jour ?

À une tentative complète par vidéo acceptée, 60 tentatives coûteraient $5,04 au taux testé. Multipliez par votre nombre mesuré de tentatives par vidéo acceptée. Par exemple, 1,5 tentative par acceptation ferait le budget de génération $7,56.

Y a-t-il une API texte-vidéo gratuite qui se réinitialise chaque jour ?

N'en supposez pas une à moins que le fournisseur ne documente l'accès à la clé API, la quantité gratuite exacte, les modèles éligibles et un calendrier de réinitialisation. Les nouveaux comptes reAPI éligibles peuvent recevoir des crédits de test promotionnels, avec disponibilité et montant affichés à l'inscription ou dans le tableau de bord ; la page de tarification publique ne promet ni octroi fixe ni réinitialisation quotidienne.^[3]

Pourquoi compter les tentatives complétées et non les clips publiés ?

Parce qu'une API peut compléter une vidéo techniquement valide qui échoue l'examen créatif, de marque, juridique ou de culture. La facture suit l'utilisation de la génération ; votre calendrier de contenu suit les clips acceptés. L'enregistrement des deux chiffres révèle le coût réel par résultat publiable.

Les tâches échouées Seedance 2.0 Mini consomment-elles des crédits ?

La documentation du modèle dit que les générations échouées sont remboursées automatiquement.^[2] Enregistrez toujours le statut final de la tâche et usage.credits plutôt que d'en supposer la valeur. Une requête échouée peut également consommer du temps et peut entraîner une tentative de remplacement facturée séparément.

Puis-je renoncer à soumettre en toute sécurité avec la même clé d'idempotence ?

Non. Chaque POST accepté crée une tâche séparée et réserve des crédits ; chaque tâche complète règle alors son propre usage.credits. Idempotency-Key est une valeur de traçage, pas de déduplication.^[4] Conservez votre propre clé de travail et ID de tâche, et arrêtez pour enquête manuelle quand le résultat de soumission est incertain.

Puis-je publier directement depuis l'URL de vidéo retournée ?

Archivez d'abord le fichier. Les liens de sortie de tâche ne sont pas un substitut pour le stockage que vous contrôlez, et la publication directe ignore l'étape d'examen. Enregistrez la vidéo, examinez-la, puis transmettez votre objet stocké au flux de travail de publication.^[5]

107,2 secondes est-il le temps de génération normal ?

Nous ne savons pas. C'est le temps écoulé d'un test unique. Mesurer la latence ou la fiabilité normales nécessite de nombreuses exécutions datées et un exemple défini, incluant les tâches échouées et expirées.

Conclusion

La réponse utile à "Combien coûte une vidéo IA quotidienne ?" n'est pas seulement $0,084 par appel. C'est $2,52 pour une exécution parfaite de 30 jours, ou $3,78–$7,56 quand le flux de travail fait en moyenne 1,5–3 tentatives complétées par clip accepté. Commencez par cette plage, mesurez votre propre taux de passage d'examen et tenez les crédits gratuits hors du plan de capacité récurrente.

Le premier jalon de production est tout aussi pratique : une clé de travail quotidien déclarée atomiquement, un ID de tâche enregistré, une interrogation GET sûre, un fichier archivé et une approbation humaine. Une fois cette boucle efficace, la planifier chaque jour est la partie facile.

Références

1. reAPI. Catalogue de modèles vidéo et page du modèle Seedance 2.0 Mini. Consulté le 3 septembre 2026.
2. reAPI. Documentation API Seedance 2.0 Mini. Consulté le 3 septembre 2026.
3. reAPI. Tarification. Consulté le 3 septembre 2026.
4. reAPI. Aperçu de l'API. Consulté le 3 septembre 2026.
5. reAPI. Statut de tâche et documentation d'interrogation. Consulté le 3 septembre 2026.
6. reAPI. Enregistrement de test du fumée Seedance 2.0 Mini de première partie. Tâche task_01a06547163473ecb7dab4478ee1abaa, complétée le 3 septembre 2026. Une requête 480p, 9:16, cinq secondes avec audio et filigrane désactivés ; 84 crédits, 107,2 secondes et une URL vidéo retournée.

Lectures complémentaires

• Comment les unités de tarification des API vidéo IA diffèrent
• Ce que les limites d'API IA gratuite couvrent réellement
• Parcourir les modèles vidéo actuels et les prix