Presupuesto de vídeos de IA: coste en 30 días

Para la configuración que probamos, generar un vídeo diario cuesta $2,52 en tarifas de generación durante 30 días. Cada intento es un clip de 5 segundos, 480p y 9:16 con seedance-2.0-mini. La única prueba de humo costó 84 créditos reAPI, o $0,084, se completó en 107,2 segundos y devolvió una URL de vídeo.^[6]

Esa es la respuesta simple, pero aún no es un presupuesto de producción. Una tarea de API completada no es necesariamente un clip que publiques. Si la revisión rechaza la mitad de tus intentos completados, el presupuesto de generación sube a $5,04 al mes. El almacenamiento, la programación, la edición y la revisión humana quedan fuera de esa cifra.

Esta guía calcula el número honesto y construye un ejemplo de trabajador único que se detiene para reconciliación manual en lugar de adivinar si un POST incierto debe repetirse.

TL;DR

• Un intento probado de 5 segundos, 480p y 9:16 en Seedance 2.0 Mini usó 84 créditos = $0,084. Treinta intentos completados idénticos costarían $2,52.
• Presupuesta por intentos completados por vídeo aceptado, no solo por publicaciones programadas. Con 1,5 intentos por clip aceptado, el presupuesto de generación de 30 días es $3,78; con dos intentos, es $5,04.
• Las cuentas nuevas elegibles pueden recibir créditos de prueba promocionales, pero la página de precios pública no promete una cantidad fija ni un restablecimiento diario.^[3] Trátalos como una pista de prototipo, no como capacidad recurrente.
• Guarda el ID de tarea inmediatamente. Cada POST repetido aceptado crea una tarea separada y una reserva de crédito; cada tarea completada liquida su propio uso. Idempotency-Key registra un valor de traza pero no desduplica solicitudes de vídeo.^[4]
• Sondea la tarea con GET aproximadamente cada cinco segundos, archiva el archivo devuelto en almacenamiento que controlas, y mantén la publicación detrás de un paso de revisión manual.^[5]
• El resultado de 107,2 segundos es una prueba de humo, no una afirmación sobre velocidad promedio, tiempo de actividad o calidad visual.

La pregunta sobre vídeos diarios que la gente realmente hace

¿Necesitas una verdadera API REST que pueda hacer uno o dos clips verticales cortos cada día, devolver una URL HTTPS pública, y encajar en un flujo de publicación automatizado? Para un prototipo de 9:16 de cuatro a cinco segundos, el costo es solo la mitad de la pregunta. La recuperación es importante tan pronto como el prototipo se convierte en un horario: el flujo de trabajo necesita estado duradero y una política de reintento deliberada antes de necesitar un prompt inteligente.

Una ejecución de 107 segundos, con una conclusión estrecha

La prueba utilizó la configuración reAPI actual más económica que encontramos que acepta un prompt de texto y admite explícitamente 9:16 y una duración de cuatro a cinco segundos: Seedance 2.0 Mini a 480p.^[1] La documentación del modelo permite 480p o 720p, salida 9:16, y duraciones de 4 a 15 segundos.^[2]

Resultado archivado de esta prueba de humo exacta: cinco segundos, 480p, 9:16, audio desactivado, marca de agua desactivada. Se verificaron la finalización técnica y la facturación; la aceptación creativa no fue puntuada.

La tarifa actual de 480p es $0,016625 por segundo facturable.^[1] reAPI factura un crédito como $0,001 y redondea una tarea al siguiente crédito completo.^[2] Para la solicitud de prueba:

ceil($0.016625 × 5 seconds × 1,000 credits per dollar)
= ceil(83.125 credits)
= 84 credits
= $0.084

Un POST aceptado reserva créditos para su propia tarea. La reserva se liquida cuando esa tarea alcanza un estado terminal: lee status junto con usage.credits en lugar de tratar la retención de admisión como la factura final. Seedance 2.0 Mini reembolsa una generación fallida bajo su política de facturación documentada.^[2][5]

Este único resultado confirma la ruta de solicitud, el estado de finalización, la URL devuelta y el cargo. No puede establecer un tiempo de renderización típico, una tasa de éxito, una tasa de aceptación o una puntuación de calidad visual.

Descarga el registro de prueba de humo. Contiene la configuración de la solicitud, el ID de la tarea, el tiempo transcurrido, el estado terminal y los créditos liquidados. Se omite la URL de tarea temporal; el registro apunta al mismo vídeo en el almacenamiento CDN permanente de reAPI.

Los precios pueden cambiar. Consulta la página del modelo Seedance 2.0 Mini en vivo antes de convertir estas cifras en una cotización al cliente o un límite de gasto riguroso.

Un presupuesto de 30 días comienza con intentos completados

El cálculo mensual mínimo es sencillo:

30 days × 84 credits = 2,520 credits = $2.52

Esto supone que un intento completado se convierte en un vídeo aceptado cada día. Una fórmula de planificación más útil:

monthly generation cost
= days × videos per day × completed attempts per accepted video × cost per attempt

Para un clip aceptado por día con la tarifa probada:

"1,5 intentos" es un promedio mensual, no media solicitud: 15 clips podrían pasar la primera vez y 15 necesitarían un reemplazo. Cuento generaciones completadas rechazadas por movimiento deficiente, composición o desajuste con el resumen.

La resolución y la duración también cambian el costo unitario inicial. Las siguientes cifras aplican la tarifa documentada actual y la fórmula de facturación; solo la fila de 480p de cinco segundos se ejecutó como la prueba de humo para este artículo.

Estos son costos de generación, no costos totales de contenido. Excluyen escritura de prompts, activos de origen, edición, subtítulos, licencias de música, almacenamiento de objetos, alojamiento de automatización, tarifas de API de plataforma, y el tiempo dedicado a aprobar cada clip.

Por qué los créditos gratis no son capacidad sostenible

Los créditos gratis pueden demostrar que la autenticación, los campos de solicitud, el sondeo y la descarga funcionan. No pueden soportar una promesa recurrente sin una cantidad conocida y una regla de restablecimiento.

Las cuentas nuevas elegibles pueden recibir créditos de prueba promocionales; la disponibilidad y la cantidad se muestran al registrarse o en el panel de control. La página de precios pública no promete una cantidad fija ni un restablecimiento diario.^[3] Eso hace que la concesión sea inadecuada como capacidad mensual confiable. La misma regla se aplica a las asignaciones de aplicaciones de consumidor: sin acceso a API documentado, límites y comportamiento de restablecimiento, los créditos de interfaz de usuario no son un presupuesto de API.

Usa el saldo gratuito para probar una ruta estrecha. Luego presupuesta el flujo de trabajo de estado estable a la tarifa pagada y trata cualquier crédito gratuito como una reducción temporal. Eso hace que el proyecto sea viable después del lanzamiento en lugar de solo en el día de demostración.

Antes de automatizar la primera solicitud

Para una configuración amigable para principiantes, prepara estas piezas:

• Una cuenta reAPI y una clave de API del lado del servidor. Nunca pongas la clave en código de navegador, un repositorio público o un flujo de trabajo descargable.
• Un prompt que describe un disparo corto. Cinco segundos no son suficientes para una historia de múltiples escenas.
• Un programador como cron, GitHub Actions, n8n o un trabajador en cola.
• Un lugar duradero para guardar la clave del trabajo diario y el ID de tarea reAPI.
• Almacenamiento que controles para archivos completados.
• Una persona que revisará el clip antes de que se publique.

Los ejemplos a continuación utilizan fechas UTC. Si el calendario de contenido sigue una zona horaria local, calcula la fecha del trabajo en esa zona consistentemente. De lo contrario, un trabajo cerca de la medianoche puede recibir la clave del día equivocado.

Envía un vídeo 9:16 con cURL

Comienza configurando la clave de API en tu shell:

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

Envía una tarea y guarda la respuesta antes de hacer cualquier otra cosa:

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

Abre submit.json y copia su id. Si tienes jq, esto lo extrae:

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

El sondeo utiliza GET, que no consume créditos:^[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

Ejecuta el último comando nuevamente después de aproximadamente cinco segundos mientras el estado es processing. Los estados terminales documentados son completed y failed. No reenvíes el POST solo porque la primera consulta no tiene vídeo todavía.

Construye un flujo de trabajo diario más seguro en Node.js

El ejemplo de cURL prueba los campos. El script a continuación es un guardia de trabajador único, como máximo una vez, no una cola exactamente una vez. Guarda la intención antes del envío, registra el ID de tarea tan pronto como llega la respuesta, limita cada llamada de red, archiva localmente y se detiene para reconciliación manual siempre que no pueda saber si un POST fue aceptado. Utiliza Node.js 20 o posterior y sin paquetes externos. No ejecutes dos copias contra el mismo archivo JSON.

Guárdalo como 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();

Ejecutalo una vez:

node daily-video.mjs

El archivo JSON es reiniciable en una máquina, pero no es un bloqueo multi-trabajador. En producción, inserta una fila de base de datos con una job_key única, luego deja que solo el trabajador que gane una reclamación atómica lo mueva de scheduled a submitting. Una reclamación de base de datos evita que dos trabajadores activos se envíen juntos. No puede hacer atómico una escritura de base de datos y una solicitud de API externa.

Qué sucede después de un bloqueo

La siguiente acción segura depende del último estado duradero que llegó al almacenamiento:

El estado incierto es el vacío inevitable. Una conexión puede fallar después de que reAPI acepte una solicitud pero antes de que el ID de tarea llegue a tu proceso. El script envía la clave del trabajo diario como Idempotency-Key para que los registros puedan correlacionar el intento, pero reAPI registra ese encabezado solo para rastrear; no desduplica. ^[4] Un POST segundo aceptado crea otra tarea y reserva, y una segunda finalización liquida otro cargo. Si los registros o el panel de control no pueden resolver la ambigüedad, el operador debe elegir entre omitir el clip de ese día y arriesgar un duplicado. No hay una respuesta honesta y automática exactamente una vez en este ejemplo.

La búsqueda de tareas es diferente. Reintentar GET no crea una generación ni usa créditos. El ejemplo limita cada solicitud, se detiene en errores 4xx deterministas, respeta Retry-After en 429, y reintenta errores de red o respuestas 5xx dentro de la ventana de sondeo de 30 minutos. Un intervalo de cinco segundos también evita leer repetidamente el caché en vuelo de cinco segundos del punto de extremo de tarea.^[5]

Revisa y almacena el clip antes de publicar

El trabajo de la API termina cuando entrega el archivo. Un clip técnicamente completado puede misrepresentar el resumen o fallar en una alimentación social. Revisa cada resultado por:

• el tema, la acción y el movimiento de cámara previstos;
• objetos distorsionados, manos, caras, empaques o logotipos;
• palabras no deseadas o afirmaciones de productos inventadas;
• parpadeo, cambios de escena repentinos o recortes inseguros;
• derechos del prompt, material de referencia, música y similitudes;
• los requisitos técnicos y de divulgación actuales de la plataforma de destino.

Marca un clip approved solo después de esa verificación. Si falla, crea un reintento deliberadamente contado por separado como daily-short:2026-09-03:retry-1; nunca borres el primer intento del libro mayor de costos.

Mueve el MP4 antes de agregarlo a la cola de publicación de mañana. La URL de salida de reAPI es una ubicación de entrega, no una biblioteca de medios permanente.^[5] El tutorial guarda localmente; usa S3, R2 o tu almacén de objetos normal en una implementación efímera.

Lo que la cifra de $2,52 no promete

El número mensual es un escenario transparente, no una garantía. Asume el mismo precio, duración, resolución y número de intentos completados durante 30 días. No establece:

• tiempo de cola o generación normal de una observación de 107,2 segundos;
• tiempo de actividad del servicio o una tasa de fallas;
• una tasa de aceptación visual para tus prompts;
• dimensiones exactas de salida más allá de la configuración solicitada de 480p y 9:16;
• publicación exitosa en ninguna plataforma social;
• precios futuros o disponibilidad de crédito gratuito.

Mantén esas variables visibles en el panel de control. Como mínimo, registra job_key, task_id, configuración solicitada, estado final, usage.credits, decisión de revisión, y URL de objeto archivado. Después de 30 días, reemplaza el número de intentos por video asumido con tu propia tasa de aceptación medida.

Preguntas frecuentes

¿Cuánto cuesta un vídeo de IA vertical de cinco segundos por día?

La configuración Seedance 2.0 Mini probada costó 84 créditos, o $0,084, para una tarea completada de cinco segundos, 480p y 9:16. Con un intento completado por día, 30 días cuesta $2,52. Consulta la página de precio del modelo en vivo antes de presupuestar un mes futuro.

¿Qué pasa si quiero dos vídeos por día?

Con un intento completado por vídeo aceptado, 60 intentos costarían $5,04 con la tarifa probada. Multiplica eso por tus intentos medidos por vídeo aceptado. Por ejemplo, 1,5 intentos por aceptación haría que el presupuesto de generación sea $7,56.

¿Existe una API de texto a vídeo gratuita que se restablece cada día?

No asumas una a menos que el proveedor documente acceso a claves de API, la cantidad exacta gratuita, modelos elegibles y un horario de restablecimiento. Las cuentas reAPI elegibles pueden recibir créditos de prueba promocionales, con disponibilidad y cantidad mostradas al registrarse o en el panel de control; la página de precios pública no promete una concesión fija o restablecimiento diario.^[3]

¿Por qué contar intentos completados en lugar de clips publicados?

Porque una API puede completar un vídeo técnicamente válido que falla en revisión creativa, marca, legal o de recorte. La factura sigue al uso de generación; tu calendario de contenido sigue clips aceptados. Registrar ambos números revela el costo real por resultado publicable.

¿Los trabajos Seedance 2.0 Mini fallidos cuestan créditos?

La documentación del modelo dice que las generaciones fallidas son reembolsadas automáticamente.^[2] Aún así registra el estado final de la tarea y usage.credits en lugar de asumir el valor. Una solicitud fallida también puede costar tiempo y puede llevar a un intento de reemplazo facturado por separado.

¿Puedo reintentar con seguridad el envío con la misma clave de idempotencia?

No. Cada POST aceptado crea una tarea separada y reserva créditos; cada tarea completada luego liquida su propio usage.credits. Idempotency-Key es un valor de traza, no deduplicación.^[4] Persiste tu propia clave de trabajo e ID de tarea, y detente para investigación manual cuando el resultado del envío sea incierto.

¿Puedo publicar directamente desde la URL del vídeo devuelto?

Archiva el archivo primero. Los enlaces de salida de tarea no son un sustituto del almacenamiento que controlas, y la publicación directa omite el paso de revisión. Guarda el vídeo, revísalo y luego pasa tu objeto almacenado al flujo de trabajo de publicación.^[5]

¿Son 107,2 segundos el tiempo de generación normal?

No lo sabemos. Es el tiempo transcurrido de una prueba de humo. Medir latencia o confiabilidad normal requiere muchas ejecuciones fechadas y una muestra definida, incluyendo tareas fallidas y agotadas.

Conclusión

La respuesta útil a "¿Cuánto cuesta generar vídeos de IA diarios?" no es simplemente $0,084 por llamada. Es $2,52 para una ejecución perfecta de 30 días, o $3,78–$7,56 cuando el flujo de trabajo promedia 1,5–3 intentos completados por clip aceptado. Comienza con ese rango, mide tu propia tasa de aprobación de revisión, y mantén los créditos gratis fuera del plan de capacidad recurrente.

El primer hito de producción es igualmente práctico: una clave de trabajo diaria reclamada atómicamente, un ID de tarea guardado, sondeo GET seguro, un archivo archivado, y una aprobación humana. Una vez que ese ciclo funciona, programarlo cada día es la parte fácil.

Referencias

1. reAPI. Catálogo de modelos de vídeo y página del modelo Seedance 2.0 Mini. Consultado el 3 de septiembre de 2026.
2. reAPI. Documentación de API de Seedance 2.0 Mini. Consultado el 3 de septiembre de 2026.
3. reAPI. Precios. Consultado el 3 de septiembre de 2026.
4. reAPI. Descripción general de la API. Consultado el 3 de septiembre de 2026.
5. reAPI. Estado de tarea y documentación de sondeo. Consultado el 3 de septiembre de 2026.
6. reAPI. Registro de prueba de humo Seedance 2.0 Mini de primera parte. Tarea task_01a06547163473ecb7dab4478ee1abaa, completada el 3 de septiembre de 2026. Una solicitud de 480p, 9:16, cinco segundos con audio y marca de agua desactivados; 84 créditos, 107,2 segundos, y una URL de vídeo devuelta.

Lectura adicional

• Cómo difieren las unidades de precios de API de vídeo de IA
• Qué cubren realmente los límites de API de IA gratuita
• Explora modelos de vídeo y precios actuales