Was kostet tägliche AI-Video-Generierung? 30-Tage API-Budget

Für die getestete Konfiguration kostet ein Video pro Tag über 30 Tage insgesamt 2,52 $ an Generierungsgebühren. Jeder Versuch ist ein fünfsekündiger, 480p, 9:16 Clip mit seedance-2.0-mini. Der einzelne Testlauf verbrauchte 84 reAPI Credits, oder 0,084 $, kam nach 107,2 Sekunden zu Ende und lieferte eine Video-URL.^[6]

Das ist die einfache Antwort, aber noch kein Produktions-Budget. Ein fertiggestellter API-Task ist nicht unbedingt ein Clip, den du veröffentlichst. Falls die Überprüfung die Hälfte deiner Versuche ablehnt, verdoppelt sich das Generierungs-Budget auf 5,04 $ pro Monat. Speicher, Planung, Bearbeitung und menschliche Überprüfung fallen nicht in diese Zahl.

Dieser Leitfaden berechnet die ehrliche Summe und zeigt ein Beispiel mit einer einzelnen Worker, die für manuelle Abgleichung pausiert, statt zu raten, ob ein unsicherer POST wiederholt werden sollte.

TL;DR

• Ein getesteter 5-sekündiger, 480p, 9:16 Seedance 2.0 Mini Task verbrauchte 84 Credits = 0,084 $. Dreißig identische fertiggestellte Versuche würden 2,52 $ kosten.
• Budget nach fertiggestellten Versuchen pro akzeptiertem Video, nicht nur geplanten Posts. Bei 1,5 Versuchen pro akzeptiertem Clip betragen die 30-Tage Generierungskosten 3,78 $; bei zwei Versuchen sind es 5,04 $.
• Berechtigte neue Konten können Promo-Credits erhalten, aber die öffentliche Preisseite verspricht keine feste Menge oder täglichen Reset.^[3] Behandle sie als Test-Laufzeit, nicht als regelmäßige Kapazität.
• Speichere die Task-ID sofort. Jeder akzeptierte wiederholte POST erstellt einen separaten Task und reserviert Credits; jede fertiggestellte Task begleicht ihre eigene Nutzung. Idempotency-Key speichert einen Trace-Wert, dedupliziert aber keine Video-Anfragen.^[4]
• Frage den Task mit GET etwa alle fünf Sekunden ab, archiviere die zurückgegebene Datei auf einem Speicher, den du kontrollierst, und halte die Veröffentlichung hinter einem manuellen Review-Schritt zurück.^[5]
• Das 107,2-Sekunden-Ergebnis ist ein einzelner Test, kein Anspruch auf durchschnittliche Geschwindigkeit, Verfügbarkeit oder visuelle Qualität.

Die tägliche Video-Frage, die Leute wirklich stellen

Brauchst du eine echte REST API, die ein oder zwei kurze vertikale Clips pro Tag machen, eine öffentliche HTTPS-URL zurückgeben und in einen automatisierten Posting-Flow passen kann? Für einen 4-5-sekündigen 9:16 Prototyp ist Kosten nur die halbe Frage. Wiederherstellung wird wichtig, sobald der Prototyp zum Zeitplan wird: der Workflow braucht dauerhaften State und eine bewusste Retry-Strategie, bevor er eine kluge Prompt braucht.

Ein 107-Sekunden-Lauf mit enger Schlussfolgerung

Der Test nutzte die kostengünstigste reAPI-Konfiguration, die wir fanden und die einen Text-Prompt akzeptiert und sowohl 9:16 als auch 4-5-sekündige Dauer unterstützt: Seedance 2.0 Mini in 480p.^[1] Die Modell-Dokumentation erlaubt 480p oder 720p, 9:16 Ausgabe und Dauer von 4 bis 15 Sekunden.^[2]

Die archivierte Ausgabe dieses exakten Tests: fünf Sekunden, 480p, 9:16, Audio aus und Wasserzeichen aus. Technischer Abschluss und Abrechnung wurden überprüft; kreative Annahme wurde nicht bewertet.

Der aktuelle 480p-Satz liegt bei 0,016625 $ pro abrechenbarer Sekunde.^[1] reAPI berechnet einen Credit als 0,001 $ und rundet einen Task auf den nächsten ganzen Credit auf.^[2] Für die Test-Anfrage:

ceil(0,016625 $ × 5 Sekunden × 1.000 Credits pro Dollar)
= ceil(83,125 Credits)
= 84 Credits
= 0,084 $

Ein akzeptierter POST reserviert Credits für seinen eigenen Task. Die Reservierung wird begleicht, wenn dieser Task einen Endzustand erreicht: Lese status zusammen mit usage.credits, anstatt den Admissions-Hold als endgültige Rechnung zu behandeln. Seedance 2.0 Mini erstattet eine fehlgeschlagene Generierung unter seiner dokumentierten Abrechnungsrichtlinie.^[2][5]

Dieses eine Ergebnis bestätigt den Request-Pfad, den Completion-Status, die zurückgegebene URL und die Abrechnung. Es kann keine typische Render-Zeit, Erfolgsrate, Acceptance-Rate oder Visual-Quality-Score festlegen.

Lade den Testbericht herunter. Er enthält die Request-Einstellungen, Task-ID, verstrichene Zeit, Endzustand und abgerechnete Credits. Die temporäre Task-URL wird weggelassen; der Bericht zeigt auf dasselbe Video in dauerhaftem reAPI-CDN-Speicher.

Die Preise können sich ändern. Prüfe die Live-Seedance 2.0 Mini Modellseite, bevor du diese Zahlen in ein Kundenangebot oder eine harte Ausgabenlimite umwandelst.

Ein 30-Tage Budget beginnt mit fertiggestellten Versuchen

Die minimale monatliche Berechnung ist einfach:

30 Tage × 84 Credits = 2.520 Credits = 2,52 $

Das setzt voraus, dass ein fertiggestellter Versuch jeden Tag zu einem akzeptierten Video wird. Eine hilfreichere Planungsformel ist:

monatliche Generierungskosten
= Tage × Videos pro Tag × fertiggestellte Versuche pro akzeptiertem Video × Kosten pro Versuch

Für ein akzeptiertes Clip pro Tag zum getesteten Satz:

„1,5 Versuche" ist ein monatlicher Durchschnitt, nicht eine halbe Anfrage: 15 Clips könnten beim ersten Mal bestehen, 15 brauchen einen Austausch. Zähle fertiggestellte Generierungen, die wegen schlechter Bewegung, Komposition oder Nichtübereinstimmung mit dem Briefing abgelehnt werden.

Auflösung und Dauer ändern auch die Stückkosten. Die folgenden Zahlen wenden den aktuellen dokumentierten Satz und die Abrechnungsformel an; nur die 5-Sekunden-480p-Reihe wurde als Test für diesen Artikel ausgeführt.

Das sind Generierungskosten, nicht Gesamtkosten. Sie schließen Prompt-Schreiben, Quellmaterial, Bearbeitung, Untertitel, Musik-Lizenzierung, Objekt-Speicher, Automations-Hosting, Plattform-API-Gebühren und die Zeit, die du für die Genehmigung jedes Clips aufwendest, aus.

Warum Free Credits keine nachhaltige Kapazität sind

Free Credits können beweisen, dass Authentifizierung, Request-Felder, Polling und Download funktionieren. Sie können ohne bekannte Menge und Erneuerungsregel keine regelmäßige Zusage erfüllen.

Berechtigte neue Konten können Promo-Credits erhalten; Verfügbarkeit und Menge werden bei der Anmeldung oder im Dashboard angezeigt. Die öffentliche Preisseite verspricht keine feste Menge oder täglichen Reset.^[3] Das macht den Grant als zuverlässige monatliche Kapazität ungeeignet. Die gleiche Regel gilt für Verbraucher-App-Guthaben: Ohne dokumentierten API-Zugriff, Limits und Reset-Verhalten sind UI-Credits kein API-Budget.

Nutze den Free-Saldo, um einen engen Pfad zu testen. Dann budget den Steady-State-Workflow zum bezahlten Satz und behandle alle Free Credits als temporäre Reduktion. Das macht das Projekt nach dem Start rentabel, statt nur am Demo-Tag.

Bevor du die erste Anfrage automatisierst

Für ein anfängerfreundliches Setup bereite diese Teile vor:

• Ein reAPI-Konto und Server-API-Schlüssel. Lege den Schlüssel niemals in Browser-Code, ein öffentliches Repository oder einen herunterladbaren Workflow.
• Ein Prompt, der eine kurze Szene beschreibt. Fünf Sekunden reichen nicht für eine Multi-Szenen-Geschichte.
• Ein Scheduler wie cron, GitHub Actions, n8n oder ein Queue-Worker.
• Ein dauerhafter Ort, um den täglichen Job-Schlüssel und die reAPI Task-ID zu speichern.
• Speicher, den du für fertige Dateien kontrollierst.
• Eine Person, die den Clip überprüft, bevor er veröffentlicht wird.

Die folgenden Beispiele verwenden UTC-Termine. Falls der Content-Kalender eine lokale Zeitzone folgt, berechne das Jobdatum konsistent in dieser Zone. Sonst kann ein Job in der Nähe von Mitternacht das Tagesdatum falsch erhalten.

Einen 9:16 Video mit cURL einreichen

Beginne damit, den API-Schlüssel in deiner Shell zu setzen:

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

Reiche einen Task ein und speichere die Antwort, bevor du etwas anderes machst:

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

Öffne submit.json und kopiere seine id. Falls du jq hast, extrahiert das es:

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

Polling nutzt GET, das keine Credits verbraucht:^[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

Führe den letzten Befehl noch mal nach etwa fünf Sekunden aus, während der Status processing ist. Die dokumentierten Endzustände sind completed und failed. Reiche den POST nicht nur deshalb erneut ein, weil die erste Abfrage kein Video hat.

Einen sicheren täglichen Workflow in Node.js bauen

Das cURL-Beispiel beweist die Felder. Das Skript unten ist ein Single-Worker, At-Most-Once Guard, nicht eine Exactly-Once-Queue. Es speichert die Absicht vor der Einreichung, zeichnet die Task-ID auf, sobald die Antwort ankommt, begrenzt jeden Netzwerk-Call, archiviert lokal und pausiert für manuelle Abgleichung, wann immer es nicht weiß, ob ein POST akzeptiert wurde. Es nutzt Node.js 20 oder neuer und keine externen Pakete. Führe nicht zwei Kopien gegen die gleiche JSON-Datei aus.

Speichere es als 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();

Führe es einmal aus:

node daily-video.mjs

Die JSON-Datei kann auf einer Maschine neu gelesen werden, aber es ist keine Multi-Worker-Sperre. In der Produktion füge eine Datenbankzeile mit eindeutigem job_key ein, dann lass nur den Worker, der einen atomaren Anspruch gewinnt, sie von scheduled zu submitting bewegen. Ein Datenbank-Anspruch verhindert, dass zwei Live-Worker zusammen einreichen. Es kann einen Datenbankschreibvorgang und eine externe API-Anfrage nicht atomar machen.

Was passiert nach einem Crash

Die sichere nächste Aktion hängt vom letzten Zustand ab, der den Speicher erreichte:

Der unsichere Zustand ist die unvermeidbare Lücke. Eine Verbindung kann fehlschlagen, nachdem reAPI eine Anfrage akzeptiert, aber bevor die Task-ID deinen Prozess erreicht. Das Skript sendet den täglichen Job-Schlüssel als Idempotency-Key, damit Logs den Versuch verknüpfen können, aber reAPI zeichnet diesen Header nur zur Verfolgung auf; es dedupliziert nicht.^[4] Ein akzeptierter zweiter POST erstellt einen anderen Task und eine Reservierung, und ein zweiter Abschluss begleicht eine andere Gebühr. Wenn Logs oder das Dashboard die Mehrdeutigkeit nicht klären können, muss der Operator zwischen Auslassen dieses Tages Clip und Risiko eines Duplikats wählen. Es gibt keine ehrliche automatische Exactly-Once-Antwort in diesem Beispiel.

Task-Lookup ist anders. Retrying GET erstellt weder eine Generierung noch nutzt Credits. Das Beispiel begrenzt jeden Request, stoppt bei determinierten 4xx Fehlern, ehrt Retry-After auf 429 und versucht Netzwerkfehler oder 5xx Responses innerhalb des 30-Minuten-Polling-Fensters erneut. Ein fünf-Sekunden-Intervall vermeidet auch wiederholtes Lesen des fünf-Sekunden-In-Flight-Cache des Task-Endpoints.^[5]

Review und speichere den Clip vor der Veröffentlichung

Der API-Job endet, wenn er die Datei ausliefert. Ein technisch fertiggestellter Clip kann immer noch den Brief falsch darstellen oder auf einem Social Feed fehlschlagen. Überprüfe jedes Ergebnis auf:

• das beabsichtigte Subjekt, die Aktion und die Kamerabewegung;
• verformte Objekte, Hände, Gesichter, Verpackung oder Logos;
• unerwünschte Wörter oder erfundene Produktansprüche;
• Flimmern, plötzliche Szenenwechsel oder unsichere Zuschnitte;
• Rechte an dem Prompt, Referenzmaterial, Musik und Likenesses;
• die aktuellen technischen und Disclosure-Anforderungen der Zielplattform.

Markiere einen Clip approved nur nach dieser Prüfung. Falls er fehlschlägt, erstelle einen separaten gezählten Retry wie daily-short:2026-09-03:retry-1; lösche den ersten Versuch nie aus dem Kostenplan.

Verschiebe die MP4, bevor du sie zur Veröffentlichungs-Queue von morgen hinzufügst. Die reAPI Ausgabe-URL ist ein Handoff-Ort, nicht eine permanente Medienbibliothek.^[5] Das Tutorial speichert lokal; nutze S3, R2 oder deinen normalen Objektspeicher auf einer ephemeran Bereitstellung.

Was die 2,52 $ Zahl nicht verspricht

Die monatliche Summe ist ein durchsichtiges Szenario, keine Garantie. Es geht davon aus, dass der gleiche Preis, die Dauer, Auflösung und Anzahl der fertiggestellten Versuche für 30 Tage. Es stellt nicht fest:

• normale Queue oder Generierungszeit aus einer 107,2-Sekunden-Beobachtung;
• Service-Verfügbarkeit oder eine Fehlerrate;
• eine visuelle Akzeptanzrate für deine Prompts;
• genaue Ausgabedimensionen über die angeforderten 480p und 9:16 Einstellungen hinaus;
• erfolgreiche Veröffentlichung auf jeder Social Platform;
• zukünftige Preise oder Free-Credit-Verfügbarkeit.

Halte diese Variablen im Dashboard sichtbar. Zeichne mindestens job_key, task_id, angeforderte Einstellungen, Endstatus, usage.credits, Review-Entscheidung und archivierte Objekt-URL auf. Nach 30 Tagen ersetze die angenommenen Versuche pro Video Zahl mit deinem eigenen gemessenen Acceptance-Rate.

Häufig gestellte Fragen

Wie viel kostet ein fünf-sekündiger vertikaler AI-Video pro Tag?

Die getestete Seedance 2.0 Mini Konfiguration verbrauchte 84 Credits, oder 0,084 $, für einen fertiggestellten fünf-sekündigen 480p 9:16 Task. Bei einem fertiggestellten Versuch pro Tag kosten 30 Tage 2,52 $. Prüfe die Live-Modellseite, bevor du ein Budget für einen zukünftigen Monat machst.

Was wenn ich zwei Videos pro Tag will?

Bei einem fertiggestellten Versuch pro akzeptiertem Video würden 60 Versuche zum getesteten Satz 5,04 $ kosten. Multipliziere das mit deinen gemessenen Versuchen pro akzeptiertem Video. Zum Beispiel würden 1,5 Versuche pro Acceptance den Generierungs-Budget zu 7,56 $ machen.

Gibt es eine Free Text-to-Video API, die täglich zurückgesetzt wird?

Setze nicht eine ein, es sei denn, der Provider dokumentiert API-Key-Zugriff, die genaue Free-Menge, berechtigte Modelle und einen Reset-Zeitplan. Berechtigte reAPI-Konten können Promo-Credits erhalten, mit Verfügbarkeit und Menge bei Anmeldung oder im Dashboard angezeigt; die öffentliche Preisseite verspricht keinen festen Grant oder täglichen Reset.^[3]

Warum fertiggestellte Versuche statt veröffentlichter Clips zählen?

Weil eine API einen technisch gültigen Video fertigstellen kann, der kreativen, Marken-, Rechts- oder Zuschnitt-Überprüfung fehlschlägt. Die Rechnung folgt Generierungsnutzung; dein Content-Kalender folgt akzeptierten Clips. Das Aufzeichnen beider Nummern zeigt die echten Kosten pro veröffentlichbarem Ergebnis.

Kosten fehlgeschlagene Seedance 2.0 Mini Tasks Credits?

Die Modell-Dokumentation sagt, dass fehlgeschlagene Generierungen automatisch erstattet werden.^[2] Zeichne immer noch den Endstatus des Tasks und usage.credits auf, anstatt den Wert anzunehmen. Ein fehlgeschlagener Request kann Zeit kosten und kann zu einem separaten abgerechneten Ersatz-Versuch führen.

Kann ich die Einreichung sicher mit dem gleichen Idempotency-Schlüssel erneut versuchen?

Nein. Jeder akzeptierte POST erstellt einen separaten Task und reserviert Credits; jeder fertiggestellte Task begleicht dann seine eigene usage.credits. Idempotency-Key ist ein Trace-Wert, nicht Deduplication.^[4] Behalte deinen eigenen Job-Schlüssel und die Task-ID, und pausiere für manuelle Untersuchung, wenn das Einreichungs-Ergebnis unsicher ist.

Kann ich direkt von der zurückgegebenen Video-URL veröffentlichen?

Archiviere die Datei zuerst. Task-Ausgabe-Links sind kein Ersatz für Speicher, den du kontrollierst, und direkte Veröffentlichung überspringt den Review-Schritt. Speichere das Video, überprüfe es, dann gib dein gespeichertes Objekt an den Veröffentlichungs-Workflow weiter.^[5]

Ist 107,2 Sekunden die normale Generierungszeit?

Wir wissen es nicht. Es ist die verstrichene Zeit eines Test-Laufs. Messung normaler Latenz oder Zuverlässigkeit erfordert viele datierte Läufe und ein definiertes Sample, einschließlich fehlgeschlagener und zeitüberschrittener Tasks.

Fazit

Die nützliche Antwort auf „Wie viel kostet tägliche AI-Video?" ist nicht nur 0,084 $ pro Anruf. Es ist 2,52 $ für einen perfekten 30-Tage Lauf, oder 3,78 $–7,56 $ wenn der Workflow durchschnittlich 1,5–3 fertiggestellte Versuche pro akzeptiertem Clip macht. Beginne mit dieser Spanne, miss deine eigene Review-Bestehensrate und halte Free Credits aus dem Steady-State-Kapazität-Plan heraus.

Die erste Produktions-Grenze ist gleich praktisch: ein atomarer anspruchsvoller täglicher Job-Schlüssel, eine gespeicherte Task-ID, sichere GET Polling, eine archivierte Datei und eine menschliche Genehmigung. Sobald diese Schleife funktioniert, ist die Planung jeden Tag der einfache Teil.

References

1. reAPI. Video model catalog and Seedance 2.0 Mini model page. Retrieved September 3, 2026.
2. reAPI. Seedance 2.0 Mini API documentation. Retrieved September 3, 2026.
3. reAPI. Pricing. Retrieved September 3, 2026.
4. reAPI. API overview. Retrieved September 3, 2026.
5. reAPI. Task status and polling documentation. Retrieved September 3, 2026.
6. reAPI. First-party Seedance 2.0 Mini smoke-test record. Task task_01a06547163473ecb7dab4478ee1abaa, completed September 3, 2026. One 480p, 9:16, five-second request with audio and watermark disabled; 84 credits, 107.2 seconds, and one returned video URL.

Further reading

• How AI video API pricing units differ
• What free AI API limits actually cover
• Browse current video models and prices