Disclosure: I work on Revana, a pay-as-you-go API for image and video models. The code uses its SDK (npm install revana, MIT) and REST API, but the structure applies to any video API you put behind a web app.

Putting a "Generate video" button in a Next.js app sounds like one fetch. In practice video generation has three properties that shape the whole design:

• It's slow. A 5-second clip takes one to several minutes. A route handler that waits for it will hit your platform's function time limit, and a user who refreshes loses the job.
• It costs real money per request. Anyone who finds your API route can call it in a loop. The key must stay on the server, and the server must decide what one request may cost.
• It fails sometimes, and a naive retry starts a second paid job.

So the shape is: a route that starts a job and returns its id, a route that reports status, a route that serves the file, and a client that polls (or a webhook that tells you when it's done). This post builds those with the App Router.

Setup

npm install revana

# .env.local
REVANA_API_KEY=sr_live_...        # from revana.si/dashboard; server only, no NEXT_PUBLIC_ prefix
REVANA_MAX_COST_USD=2             # the most one request may cost

1. Start a job: app/api/videos/route.ts

import Revana, { RevanaError } from "revana";

const revana = new Revana(); // reads REVANA_API_KEY
const MAX_USD = Number(process.env.REVANA_MAX_COST_USD ?? 2);

// Only what your product offers. Never pass a client-chosen model or input straight through.
const MODELS: Record<string, { resolution: string; durations: number[] }> = {
  "wan-3.0": { resolution: "720p", durations: [5, 10] },
  "kling-4.0": { resolution: "720p", durations: [5, 10] },
  "seedance-2.5": { resolution: "720p", durations: [5] },
};

export async function POST(req: Request) {
  const user = await requireUser(req); // your auth: session check, plus a per-user rate limit
  const { model, prompt, duration, imageUrl } = await req.json();

  const spec = MODELS[model];
  if (!spec || !spec.durations.includes(duration) || typeof prompt !== "string" || prompt.length > 2000) {
    return Response.json({ error: "invalid request" }, { status: 400 });
  }
  const body = {
    model,
    input: {
      prompt, duration, resolution: spec.resolution, aspect_ratio: "9:16", audio: true,
      ...(imageUrl ? { image_url: imageUrl } : {}),
    },
  };

  // 1. Price the exact request (free: nothing is created or charged).
  const q = await fetch("https://api.revana.si/v1/generations/quote", {
    method: "POST",
    headers: { authorization: `Bearer ${process.env.REVANA_API_KEY}`, "content-type": "application/json" },
    body: JSON.stringify(body),
  });
  const quote = await q.json();
  if (!q.ok) return Response.json({ error: quote.error?.message ?? "cannot price this" }, { status: 422 });
  if (quote.quoted_usd > MAX_USD) {
    return Response.json({ error: `costs $${quote.quoted_usd}, over the $${MAX_USD} limit` }, { status: 402 });
  }

  // 2. Create it, capped at the quote, with the client's idempotency key.
  const key = req.headers.get("idempotency-key");
  if (!key || key.length > 100) return Response.json({ error: "Idempotency-Key header required" }, { status: 400 });
  try {
    const gen = await revana.generations.create(
      { ...body, max_cost_usd: quote.quoted_usd },
      { idempotencyKey: `${user.id}:${key}` },
    );
    await saveJob({ id: gen.id, userId: user.id, quotedUsd: quote.quoted_usd }); // your DB
    return Response.json({ id: gen.id, status: gen.status, quoted_usd: gen.quoted_usd }, { status: 202 });
  } catch (e) {
    if (e instanceof RevanaError) return Response.json({ error: e.code, message: e.message }, { status: e.status || 502 });
    throw e;
  }
}

What each part protects against:

• Allow-list, not pass-through. The client picks from your models and durations; the server fills in resolution and everything else. Otherwise someone sends resolution: "1080p", duration: 30 and you pay for it.
• Quote, then cap at the quote. POST /v1/generations/quote takes the same body as the create and answers quoted_usd (the normal price) and reserved_usd (the most it could cost if a dearer backup provider delivers). Some inputs cost more than a model's headline rate: on November 5, 2026, a 5-second 720p Seedance 2.5 clip quoted $1.05 from text but $1.25 with a start image. The quote handles that, and max_cost_usd: quoted_usd makes it a hard ceiling. A request that can't run at that price fails with max_cost_exceeded and costs nothing.
• The idempotency key comes from the client. The browser generates one key per click (below) and resends it if the request times out. The same key with the same body returns the original job instead of a second paid one. Prefixing it with the user id stops two users' keys from colliding, since keys are scoped to your Revana account, not to your users.
• Save the job with its owner. The status and file routes below check that the job belongs to the caller. Without that, anyone who guesses or sees a gen_... id can read someone else's video through your key.

requireUser and saveJob stand in for your own auth and database.

2. Report status: app/api/videos/[id]/route.ts

import Revana from "revana";

const revana = new Revana();

export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
  const user = await requireUser(req);
  const { id } = await params;
  const job = await findJob(id);
  if (!job || job.userId !== user.id) return Response.json({ error: "not found" }, { status: 404 });

  const g = await revana.generations.get(id);
  return Response.json({
    id: g.id,
    status: g.status, // queued | running | succeeded | failed
    cost_usd: g.cost_usd, // null while running, 0 if it failed
    error: g.error && { code: g.error.code, message: g.error.message, retryable: g.error.retryable },
  });
}

The browser gets only what it needs. error.message is written to be shown to the person who asked, and retryable says whether trying the same request later can work (model_busy, timeout) or whether it needs to change (content_policy, invalid_input). A failed generation is charged $0.

3. Serve the file: app/api/videos/[id]/content/route.ts

export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
  const user = await requireUser(req);
  const { id } = await params;
  const job = await findJob(id);
  if (!job || job.userId !== user.id) return new Response("not found", { status: 404 });

  const res = await fetch(`https://api.revana.si/v1/generations/${encodeURIComponent(id)}/content`, {
    headers: { authorization: `Bearer ${process.env.REVANA_API_KEY}` },
    redirect: "manual",
    cache: "no-store",
  });
  const location = res.headers.get("location");
  if (location) return Response.redirect(location, 302); // a short-lived link to the file
  return new Response(res.body, { status: res.status, headers: { "content-type": res.headers.get("content-type") ?? "video/mp4" } });
}

/content answers with a redirect to a short-lived file link. Handling the redirect yourself (redirect: "manual") means your Authorization header is never sent to the storage host, and the browser follows the link without ever seeing your key. Result files expire, so if users should keep their videos, copy the file into your own storage (S3, R2, Vercel Blob) when the job succeeds rather than relying on the link later.

4. The client: start, poll, show

"use client";
import { useEffect, useRef, useState } from "react";

export function VideoButton() {
  const [job, setJob] = useState<{ id: string; status: string; error?: { message: string } } | null>(null);
  const [error, setError] = useState<string | null>(null);
  const key = useRef<string | null>(null);

  async function start() {
    setError(null);
    key.current ??= crypto.randomUUID(); // one key per intent; reused if this request is retried
    const res = await fetch("/api/videos", {
      method: "POST",
      headers: { "content-type": "application/json", "idempotency-key": key.current },
      body: JSON.stringify({ model: "wan-3.0", prompt: "a paper boat drifting down a rainy street at night", duration: 5 }),
    });
    const data = await res.json();
    if (!res.ok) return setError(data.message ?? data.error);
    key.current = null; // the next click is a new video
    setJob(data);
  }

  useEffect(() => {
    if (!job || job.status === "succeeded" || job.status === "failed") return;
    const t = setTimeout(async () => setJob(await fetch(`/api/videos/${job.id}`).then((r) => r.json())), 5000);
    return () => clearTimeout(t);
  }, [job]);

  return (
    <div>
      <button onClick={start} disabled={!!job && !["succeeded", "failed"].includes(job.status)}>Generate video</button>
      {error && <p>{error}</p>}
      {job && job.status !== "succeeded" && job.status !== "failed" && <p>Rendering… ({job.status})</p>}
      {job?.status === "failed" && <p>{job.error?.message} You were not charged.</p>}
      {job?.status === "succeeded" && <video src={`/api/videos/${job.id}/content`} controls autoPlay muted playsInline />}
    </div>
  );
}

Polling every 5 seconds is plenty for a job that takes minutes, and it stays well clear of the API's per-second burst guard. Because the job id is in your database, you can also list a user's past and in-progress videos after a refresh instead of keeping state only in React.

5. Optional: a webhook instead of polling the API

If your app is deployed on public HTTPS, Revana's queue endpoint can call you when a job finishes. It takes the model input directly (no {model, input} wrapper), with max_cost_usd alongside it, and the callback URL in fal_webhook:

const callback = encodeURIComponent("https://your-app.example/api/revana/webhook");
const res = await fetch(`https://api.revana.si/v1/queue/revana/${model}?fal_webhook=${callback}`, {
  method: "POST",
  headers: {
    authorization: `Bearer ${process.env.REVANA_API_KEY}`,
    "content-type": "application/json",
    "idempotency-key": `${user.id}:${key}`,
  },
  body: JSON.stringify({ ...body.input, max_cost_usd: quote.quoted_usd }),
});
const { request_id } = await res.json(); // 202; store it with the user and the model

The handler, app/api/revana/webhook/route.ts:

export async function POST(req: Request) {
  const { request_id } = await req.json();
  const job = await findJobByRequestId(request_id);
  if (!job || job.done) return new Response(null, { status: 200 }); // unknown or already handled

  // Callbacks are unsigned: confirm with your own key before trusting them.
  const s = await fetch(
    `https://api.revana.si/v1/queue/revana/${job.model}/requests/${encodeURIComponent(request_id)}/status`,
    { headers: { authorization: `Bearer ${process.env.REVANA_API_KEY}` }, cache: "no-store" },
  ).then((r) => r.json());
  if (s.status !== "COMPLETED") return new Response(null, { status: 200 });

  await markJobDone(request_id, { failed: Boolean(s.error), error: s.error }); // then notify the user
  return new Response(null, { status: 200 });
}

The rules from the queue docs that this follows:

• Unsigned callbacks. Treat the POST as "something may have changed" and check the status with your key.
• At-least-once delivery. The same request_id can arrive more than once, so the handler deduplicates on it. Answer 2xx quickly; failed deliveries are retried for up to 24 hours.
• Public HTTPS on port 443, no redirects. A localhost dev server can't receive it, so keep the polling path for development.

A finished queue job's file is at GET /v1/queue/revana/{model}/requests/{request_id}/content, with your key, and the same manual-redirect handling as above.

Costs, for planning

Quotes for a 5-second, 720p, 9:16 clip with audio from text, on November 5, 2026: Wan 3.0 $0.35, Kling 4.0 $0.68, Seedance 2.5 $1.05, and Veo 3.1 Fast $0.60 for 6 seconds (it takes 4, 6 or 8). Re-quote in code rather than hard-coding these. Prices for every model are at revana.si/pricing, and GET https://api.revana.si/v1/models lists each model's options and price without a key.

If you want to try the whole flow before spending anything, minimax-h3-free is a free model in the same catalog (5 to 15 s, sound always on). Its quote comes back $0.00. The account needs one top-up first (the smallest pack is $10), but free jobs never spend it.

Checklist

• Key in a server-only env var; the browser never sees it.
• Allow-list models and options on the server.
• Quote the exact request; cap max_cost_usd at the quote (or at reserved_usd if you'd rather allow backups).
• One idempotency key per user intent, generated by the client, namespaced by user.
• Store job ids with their owner, and check ownership on every read.
• Don't wait in the request: poll at a few seconds, or use the webhook and verify it.
• Copy finished files to your own storage if users should keep them.

The SDK source and more examples: revana-js, and revana-skills/examples/nextjs for a minimal version of these routes. API reference: revana.si/docs.

Quotes in this post are from Revana's live API on November 5, 2026.

Disclosure: I work on Revana, a pay-as-you-go API for image and video models. The scripts use its SDK (pip install revana / npm install revana, both MIT and open source), but the structure is what any batch job against a paid generation API needs.

A common job for an image-to-video API: you have a folder of product shots (shoe-red.jpg, shoe-blue.jpg, ... 40 of them) and you want a short clip of each for ads or a product page. The first version is always a for loop around one API call. It works, and then:

• you only find out what the batch cost when the invoice arrives,
• the script crashes on photo 27, you re-run it, and photos 1 to 26 are generated (and billed) again,
• one call at a time takes an hour.

This post builds a script that fixes those: it uploads the photos, quotes every clip and prints the total before spending anything, asks you to confirm, generates several in parallel, and can be re-run any number of times without paying for the same clip twice.

The models and what one clip costs

All three models below take a start frame (image_url) and keep it as the first frame of the clip. Quotes are for a 5-second, 720p, 9:16 clip with audio, with a real image as the first frame, from Revana's quote endpoint on November 5, 2026:

Look at Seedance 2.5. Its listed 720p rate is $0.21 a second, but with a first frame the quote is $0.25 a second. If you multiply the rate card by the number of photos, you'll be 16% low on that model. That's the main reason the script quotes the exact request instead of computing prices itself.

Which model is "best" for your products is a judgment call I'm not going to make for you; run three or four photos through each and compare. The script makes that cheap to do.

Setup

pip install revana httpx
export REVANA_API_KEY=sr_live_...   # from revana.si/dashboard

The SDK covers uploads, creating, waiting and downloading. It has no quote helper yet, so the script calls POST /v1/generations/quote with httpx directly. Quoting is free: nothing is created, held or charged.

The script

# photos_to_videos.py: python photos_to_videos.py ./photos --model kling-4.0
import argparse, hashlib, json, os, sys
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

import httpx
from revana import Revana, GenerationFailedError, RevanaError, WaitTimeoutError

API = "https://api.revana.si"
PROMPT = "slow camera orbit around the product, soft studio light, clean background"

p = argparse.ArgumentParser()
p.add_argument("folder", type=Path)
p.add_argument("--model", default="wan-3.0")
p.add_argument("--duration", type=int, default=5)
p.add_argument("--resolution", default="720p")
p.add_argument("--aspect", default="9:16")
p.add_argument("--budget", type=float, default=20.0, help="stop if the batch quotes above this")
p.add_argument("--workers", type=int, default=4)
p.add_argument("--yes", action="store_true", help="don't ask before spending")
args = p.parse_args()

out = args.folder / "videos"
out.mkdir(exist_ok=True)
state_file = out / "state.json"   # upload links and job ids survive a crash
state = json.loads(state_file.read_text()) if state_file.exists() else {}

def save():
    state_file.write_text(json.dumps(state, indent=2))

revana = Revana()
http = httpx.Client(base_url=API, timeout=60,
                    headers={"Authorization": f"Bearer {os.environ['REVANA_API_KEY']}"})

photos = sorted(f for f in args.folder.iterdir() if f.suffix.lower() in {".jpg", ".jpeg", ".png", ".webp"})

def request_for(photo: Path) -> dict:
    s = state.setdefault(photo.name, {})
    if "url" not in s:  # upload once; the link works for 14 days
        s["url"] = revana.uploads.upload(str(photo))["url"]
        save()
    return {
        "model": args.model,
        "input": {"prompt": PROMPT, "image_url": s["url"], "duration": args.duration,
                  "resolution": args.resolution, "aspect_ratio": args.aspect, "audio": True},
    }

# 1. Upload and quote everything first.
jobs = []
for photo in photos:
    if (out / f"{photo.stem}.mp4").exists():
        continue  # done on an earlier run
    body = request_for(photo)
    q = http.post("/v1/generations/quote", json=body)
    if q.status_code != 200:
        sys.exit(f"{photo.name}: {q.json()['error']['message']}")
    jobs.append((photo, body, q.json()["quoted_usd"]))

total = round(sum(usd for _, _, usd in jobs), 2)
print(f"{len(jobs)} clips on {args.model}: ${total:.2f}")
if total > args.budget:
    sys.exit(f"over the ${args.budget:.2f} budget; raise --budget or pick a cheaper model")
if jobs and not args.yes and input("Generate? [y/N] ").strip().lower() != "y":
    sys.exit("nothing spent")

# 2. Generate in parallel, each with a key that is stable across re-runs.
def run(job):
    photo, body, usd = job
    digest = hashlib.sha256(photo.read_bytes()).hexdigest()[:16]
    key = f"photos/{photo.name}/{digest}/{args.model}/{args.duration}s-{args.resolution}-{args.aspect}"
    try:
        video = revana.generate(**body, max_cost_usd=usd, idempotency_key=key, timeout=1800)
    except GenerationFailedError as e:
        return f"{photo.name}: failed ({e.code}, retryable={e.retryable}), charged $0"
    except WaitTimeoutError:
        return f"{photo.name}: still running after 30 min; re-run later to pick it up (same key, no new charge)"
    except RevanaError as e:
        return f"{photo.name}: refused ({e.status} {e.code}): {e.message}"
    (out / f"{photo.stem}.mp4").write_bytes(revana.generations.download(video["id"]))
    state[photo.name].update(id=video["id"], cost_usd=video["cost_usd"])
    return f"{photo.name}: ${video['cost_usd']:.2f}"

with ThreadPoolExecutor(max_workers=args.workers) as pool:
    for line in pool.map(run, jobs):
        print(line)
save()
spent = sum(s.get("cost_usd") or 0 for s in state.values())
print(f"total charged for this folder so far: ${spent:.2f}")

Run it on a few photos first. With 12 photos on Wan 3.0 at $0.35 a clip, the first lines look like this:

$ python photos_to_videos.py ./photos --model wan-3.0 --budget 5
12 clips on wan-3.0: $4.20
Generate? [y/N]

Why each piece is there

Quote, then confirm. The quote takes the exact body you'll send, image included, so the total is what the batch will normally cost. Each clip is then sent with max_cost_usd equal to its own quote. If the first provider fails and only a dearer backup is left, that clip fails (and costs $0) instead of quietly costing more. If you'd rather have the clip, pass the quote's reserved_usd (the most a backup could charge) or a looser cap. You're only ever charged for the route that delivers.

Upload once, keep the link. References must be public https:// URLs, so a local file goes through POST /v1/uploads first. revana.uploads.upload() does both steps: it gets a presigned link, PUTs the bytes, and returns a url that works for 14 days. Uploads are free (images up to 30 MB). The script saves that URL in state.json, and that matters for the next point.

An idempotency key per clip, not per run. The key is built from the photo's name, a hash of its bytes, the model and the settings. Re-run the script after a crash and every clip that was already submitted sends the same key with the same body, so the API returns the original generation instead of starting a new paid one. That only works if the body is byte-for-byte the same, which is why the upload URL is cached: re-uploading would produce a new URL, a different body, and a 409 idempotency_conflict instead of a replay. Replace a photo with a new version and its hash changes, so it gets a new key and a new clip, which is what you want.

Skip what's done. Finished clips are on disk as videos/<name>.mp4, and the loop skips them before quoting, so a re-run after a crash only quotes and generates what's missing.

Parallel, but not unlimited. Four workers is a reasonable start. If the account has too many generations running, the create call answers 429 concurrency_limit. The SDK retries 429 and 5xx responses with backoff (honoring Retry-After), and because every create carries an idempotency key, those retries can't double-submit.

Failures are free and labelled. A failed generation has cost_usd: 0 and an error.code. retryable tells you whether the same request might work later (model_busy, timeout) or needs to change (content_policy, invalid_input). The script prints it and moves on, and a re-run picks it up again.

The same thing in Node

The Node SDK has the same calls (uploads.upload, generate, generations.download). The core of the loop:

// photos-to-videos.mjs: node photos-to-videos.mjs ./photos
import Revana, { GenerationFailedError } from "revana";
import { readFile, readdir, writeFile } from "node:fs/promises";
import { createHash } from "node:crypto";
import { join, parse } from "node:path";

const dir = process.argv[2];
const model = "wan-3.0";
const revana = new Revana(); // reads REVANA_API_KEY
const auth = { authorization: `Bearer ${process.env.REVANA_API_KEY}`, "content-type": "application/json" };

const jobs = [];
for (const name of (await readdir(dir)).filter((f) => /\.(jpe?g|png|webp)$/i.test(f))) {
  const bytes = await readFile(join(dir, name));
  const type = /\.png$/i.test(name) ? "image/png" : /\.webp$/i.test(name) ? "image/webp" : "image/jpeg";
  const { url } = await revana.uploads.upload(bytes, type, name); // cache this, as in the Python version
  const body = {
    model,
    input: { prompt: "slow camera orbit around the product, soft studio light", image_url: url,
             duration: 5, resolution: "720p", aspect_ratio: "9:16", audio: true },
  };
  const q = await fetch("https://api.revana.si/v1/generations/quote", { method: "POST", headers: auth, body: JSON.stringify(body) }).then((r) => r.json());
  if (!q.quoted_usd) throw new Error(`${name}: ${q.error?.message}`);
  const key = `photos/${name}/${createHash("sha256").update(bytes).digest("hex").slice(0, 16)}/${model}/5s-720p-9:16`;
  jobs.push({ name, body: { ...body, max_cost_usd: q.quoted_usd }, key, usd: q.quoted_usd });
}

console.log(`${jobs.length} clips: $${jobs.reduce((s, j) => s + j.usd, 0).toFixed(2)}`);
// ...confirm here before spending...

const results = await Promise.allSettled(jobs.map(async (j) => {
  const video = await revana.generate(j.body, { idempotencyKey: j.key });
  await writeFile(join(dir, `${parse(j.name).name}.mp4`), Buffer.from(await revana.generations.download(video.id)));
  return `${j.name}: $${video.cost_usd}`;
}));
for (const r of results) console.log(r.status === "fulfilled" ? r.value : r.reason instanceof GenerationFailedError ? `failed, $0: ${r.reason.message}` : r.reason);

Promise.allSettled over every job starts them all at once. For more than a handful of photos, add a small concurrency limit (a pool of four, like the Python version) so you don't spend the run waiting on 429 concurrency_limit retries.

Variations

• First and last frame. Seedance 2.5, Kling 4.0, Wan 3.0 and Veo 3.1 also take end_image_url (it needs image_url). Two shots of the same product from different angles give you a controlled transition.
• Reference images instead of a start frame. Seedance 2.5 takes up to 30 image_urls and Kling 4.0 and Wan 3.0 up to 10, for "this product, in a new scene" rather than "animate this exact photo". On Seedance, image_url and reference media can't be combined in one request.
• A free dry run. minimax-h3-free takes a start frame too (5 to 15 s, sound always on) and quotes $0.00. The account needs one top-up first (the smallest pack is $10), but free jobs never spend it. Use it to test the whole pipeline before you point it at a paid model.

Prices for every model are at revana.si/pricing, and each model's options are in GET https://api.revana.si/v1/models (no key needed). The SDKs: revana-python and revana-js. API reference: revana.si/docs.

Quotes in this post are from Revana's live API on November 5, 2026.

Disclosure: I work on Revana, a pay-as-you-go API for image and video models. The workflow below calls its REST API, but the shape (price first, cap the spend, one idempotency key per job, wait without hammering the API) is what you want around any paid generation API in n8n.

Most "AI video in n8n" tutorials stop at one HTTP Request node that fires a prompt at a model. That works once in a demo. In a real workflow it breaks in three ways:

1. You find out the price afterwards. Someone changes the resolution from 720p to 1080p in a Set node and the next 200 runs cost 2.5x.
2. n8n's "Retry On Fail" can double-charge you. If the create request times out after the provider accepted it, a retry starts a second paid video.
3. Video takes minutes. A single request can't wait that long, so you need a wait loop or a callback.

This post builds a workflow out of stock n8n nodes (HTTP Request, IF, Wait, Stop and Error) that handles all three. No community node is required, though there is one at the end if you prefer it.

What you're building

Manual Trigger
  -> Settings (Set)
  -> Quote (HTTP Request, free)
  -> Within budget? (IF) --no--> Stop and Error
  -> Create generation (HTTP Request, Idempotency-Key)
  -> Wait 20 s
  -> Get generation (HTTP Request)
  -> Succeeded? (IF) --yes--> Download video (HTTP Request, file)
                     --no---> Failed? (IF) --yes--> Stop and Error
                                           --no---> back to Wait

Every Revana model goes through the same two endpoints, so the workflow is the same for Seedance 2.5, Kling 4.0, Wan 3.0, Veo 3.1 Fast and the rest. Only the model value and its options change.

1. The credential

Create an API key at revana.si/dashboard. In n8n, go to Credentials > Add credential > Header Auth:

• Name: Authorization
• Value: Bearer sr_live_...

Call it Revana API. On each HTTP Request node below, set Authentication to Generic Credential Type, Generic Auth Type to Header Auth, and pick that credential.

2. Settings

A Set node holds everything you'd want to change per run:

Valid values differ by model. GET https://api.revana.si/v1/models (no key needed) lists each model's resolutions, durations and aspect ratios, for example Seedance 2.5 takes 4 to 30 seconds and Kling 4.0 takes 3 to 30. A value a model doesn't offer is refused with 422 invalid_input before anything is charged, so a typo costs nothing.

3. Quote before you spend

POST /v1/generations/quote takes exactly the body you're about to send and answers what it will cost. It's free: nothing is created, held or charged.

Quote node (HTTP Request):

• Method: POST
• URL: https://api.revana.si/v1/generations/quote
• Send Body: on, Body Content Type: JSON, Specify Body: Using JSON
• JSON:

={{ JSON.stringify({
  model: $json.model,
  input: {
    prompt: $json.prompt,
    resolution: $json.resolution,
    duration: $json.duration,
    aspect_ratio: $json.aspect_ratio,
    audio: $json.audio
  }
}) }}

The answer has two numbers worth knowing:

• quoted_usd: the price on the first route tried. This is what a successful job normally costs.
• reserved_usd: the most it could cost if the first provider fails and a dearer backup delivers instead. That amount is held from your balance while the job runs.

With the settings above (Seedance 2.5, 720p, 5 s, 9:16, audio), the quote on November 5, 2026 was $1.05 ($0.21 per second), with up to $4.05 reserved if every backup were allowed. The same settings on Kling 4.0 quoted $0.68, on Wan 3.0 $0.35, and Veo 3.1 Fast at 6 seconds (it takes 4, 6 or 8) $0.60. Re-quote rather than copying these: prices change, and some inputs cost more than the model's headline rate. Seedance 2.5 with a first frame quoted $0.25 a second instead of $0.21.

Within budget? (IF node), Number condition:

{{ $json.quoted_usd }}   is less than or equal to   {{ $('Settings').item.json.budget_usd }}

The false branch goes to a Stop and Error node with a message like Costs ${{ $json.quoted_usd }}, over the budget.

4. Create the job, safely

Create generation (HTTP Request):

• Method: POST, URL: https://api.revana.si/v1/generations
• Send Headers: on, add Idempotency-Key = n8n-{{ $execution.id }}
• Body: the same JSON as the quote, plus a cap:

={{ JSON.stringify({
  model: $('Settings').item.json.model,
  input: {
    prompt: $('Settings').item.json.prompt,
    resolution: $('Settings').item.json.resolution,
    duration: $('Settings').item.json.duration,
    aspect_ratio: $('Settings').item.json.aspect_ratio,
    audio: $('Settings').item.json.audio
  },
  max_cost_usd: $json.quoted_usd
}) }}

Two things make this node safe to retry:

• The idempotency key is tied to the execution, not the HTTP call. Turn on Retry On Fail in the node's Settings tab. Each retry sends the same key with the same body, so if the first attempt reached the API, the retry gets the original job back (200) instead of starting a second one. Sending the same key with a different body returns 409 idempotency_conflict, which is what you want if someone edits the node between attempts. If you loop over many items in one execution, make the key per item, for example n8n-{{ $execution.id }}-{{ $itemIndex }}.
• max_cost_usd is a hard ceiling. Setting it to quoted_usd means a dearer backup provider is skipped and the job fails instead of costing more. If you'd rather get the video, set it to reserved_usd (or your budget) and let backups run; you're charged only for the route that delivers.

The response is 202 with a generation object: id, status (queued), quoted_usd, reserved_usd, and cost_usd (null until it finishes).

5. Wait without hammering the API

A 5-second 720p clip usually takes one to a few minutes, sometimes longer. Polling every second wastes executions and can hit the per-second burst guard (429 rate_limited). A loop with a Wait node is enough:

• Wait: After Time Interval, 20 seconds.
• Get generation (HTTP Request): GET https://api.revana.si/v1/generations/{{ $('Create generation').item.json.id }}
• Succeeded? (IF): {{ $json.status }} equals succeeded → download.
• Failed? (IF): {{ $json.status }} equals failed → Stop and Error with {{ $json.error.code }}: {{ $json.error.message }}. Otherwise connect the false branch back to Wait.

Two details:

• A failed generation is charged $0 (cost_usd: 0). error.retryable tells you whether sending the same request later can work (model_busy, timeout, all_routes_failed) or whether the request itself has to change (content_policy, invalid_input, max_cost_exceeded).
• Put a ceiling on the loop so a stuck job can't run forever. In the Failed? node, add an OR condition {{ $runIndex }} is greater than 60 (about 20 minutes at 20 s per lap). $runIndex counts how many times that node has run in this execution.

6. Download the file

Download video (HTTP Request):

• GET https://api.revana.si/v1/generations/{{ $json.id }}/content
• Options > Response > Response Format: File

The API redirects to a short-lived file link, and n8n follows it. The video arrives as binary data, ready for a Google Drive, S3, Slack or Write Binary File node. Result files expire, so store them; don't keep the link.

Alternative: a webhook instead of the polling loop

If your n8n is reachable on public HTTPS (n8n Cloud, or self-hosted behind a domain), you can drop the loop. Revana's queue endpoint accepts a completion webhook, and n8n's Wait node can pause until a URL is called.

1. Change Wait to Resume: On Webhook Call, HTTP Method POST, and set Limit Wait Time (for example 1 hour).
2. Change Create generation to the queue endpoint. It takes the model input directly, without the {model, input} wrapper, with max_cost_usd alongside, and the callback in the fal_webhook query parameter:

POST https://api.revana.si/v1/queue/revana/{{ $('Settings').item.json.model }}?fal_webhook={{ encodeURIComponent($execution.resumeUrl) }}
Idempotency-Key: n8n-{{ $execution.id }}

{ "prompt": "...", "resolution": "720p", "duration": 5, "aspect_ratio": "9:16", "audio": true, "max_cost_usd": 1.05 }

3. After the Wait node, don't trust the callback body. Revana's callbacks are unsigned, so fetch the result yourself with your key: GET https://api.revana.si/v1/queue/revana/{model}/requests/{{ $('Create generation').item.json.request_id }}/status, and when it's COMPLETED without an error, download .../requests/{request_id}/content with Response Format: File.

The callback URL must be public HTTPS on port 443 with no redirects, so this won't work against localhost:5678. For local development, keep the polling loop.

Testing for $0

minimax-h3-free is a free model in the same catalog (5 to 15 seconds, 480p/720p/768p, sound always on). Set model to it in Settings, and the quote comes back $0.00. The account needs one top-up first (the smallest pack is $10, an anti-abuse rule), but free jobs never spend it. It's a good way to run the whole workflow end to end before you point it at a paid model.

If you'd rather not build it

• Importable workflows. revana-skills/n8n has two ready-made JSON workflows (a text/image-to-video generator and a product-photo-to-UGC-ad flow) built the same way. Import with Workflows > Import from File, or n8n import:workflow --input=seedance-2.5-video-generator.json.
• A community node. n8n-nodes-revana (Settings > Community Nodes > Install, if your instance allows community nodes) wraps this into Generate Media, Get Generation, List Models and Chat operations, with a max-cost field and an optional wait for the result.

The same three calls work anywhere

Nothing here is n8n-specific. Make's HTTP module, Zapier's Webhooks by Zapier, Pipedream or a cron job can run the same sequence: POST /v1/generations/quote, POST /v1/generations with an Idempotency-Key and max_cost_usd, then GET /v1/generations/{id} on an interval and GET /v1/generations/{id}/content at the end. The full API is in the docs and openapi.json, and every model and price is at revana.si/pricing.

Prices and quotes in this post are from Revana's live API on November 5, 2026.

Disclosure: I work on Revana, a router for image and video models. The code below targets its API (spec: https://revana.si/openapi.json), but the failure modes and the fixes apply to any generation provider.

A demo calls a video model once and shows the result. A production pipeline calls it thousands of times, and then you see what the demo hid. Generation endpoints fail far more often than ordinary APIs, in more ways, and every failure mode has a cost:

• Capacity: the provider is at capacity (429/503) for minutes at a time, usually right when you launch a campaign.
• Slow jobs: a 10-second 1080p clip can take anywhere from 40 seconds to 15 minutes, so your HTTP client times out long before the job does.
• Refusals: the model refuses the prompt (content policy) or returns text instead of a video.
• Network: a connection drops after you've submitted, and you don't know whether the job exists.
• Billing: some providers charge for failed or timed-out jobs.

Any one of these is easy to handle. The trouble is that a naive fix for one usually makes another worse. Retrying blindly turns a dropped connection into two paid videos, and falling back to another model turns a $1 clip into a $4 one. This post builds a small pipeline that handles all five, in about 120 lines of Python.

The request shape

Every model goes through the same endpoint:

POST https://api.revana.si/v1/generations
Authorization: Bearer sr_live_...
Idempotency-Key: campaign-42/shot-07/seedance-2.5/a0
Content-Type: application/json

{
  "model": "seedance-2.5",
  "input": {
    "prompt": "close-up of hands pouring cold brew over ice, morning light",
    "resolution": "720p", "duration": 8, "aspect_ratio": "9:16", "audio": true,
    "image_url": "https://example.com/start-frame.png"
  },
  "max_cost_usd": 2.00
}

The response is 202 with a generation object (id, status, quoted_usd, reserved_usd, cost_usd, error). You poll GET /v1/generations/{id} until status is succeeded or failed, then download GET /v1/generations/{id}/content.

Two fields do most of the safety work:

• max_cost_usd is a hard ceiling per generation. If the only available route costs more, the request fails with max_cost_exceeded and nothing is charged.
• Idempotency-Key: sending the same key with the same body returns the original generation (200) instead of starting a new one. The same key with a different body is 409 idempotency_conflict.

Layer 1: routing inside one model

The same model is often sold by several upstream providers. Seedance 2.5, for example, is available from ByteDance directly and from a handful of resellers. A router can try the cheapest healthy route first and move to the next one if it's down, without the caller ever seeing the failure.

Revana does this server-side, and the generation object tells you what it may cost you:

• quoted_usd is the price on the first route tried.
• reserved_usd is the most it can cost: the dearest backup route allowed under your max_cost_usd. That amount is held from your balance while the job runs.
• cost_usd is what you were actually charged: the price of the route that delivered, 0 if it failed, null while it's running.

If you want "this model, this price, or nothing", set max_cost_usd equal to the quote and dearer backups are skipped. If you'd rather get the clip, leave headroom. To check the quote before submitting, read the live price list (no key needed):

import requests

MODELS = {m["id"]: m for m in requests.get("https://api.revana.si/v1/models", timeout=30).json()["data"]}

def quote(model: str, inp: dict) -> float:
    """Price of one generation from the live list: per_second x duration, or per_image."""
    price = MODELS[model]["price"]
    usd = price["usd"]
    if isinstance(usd, dict):
        res = inp.get("resolution")
        key = f"{res}+audio" if inp.get("audio") and f"{res}+audio" in usd else res
        usd = usd[key]
    return round(usd * inp.get("duration", 1), 4) if price["unit"] == "per_second" else usd

As of 2026-11-05, quote("seedance-2.5", {"resolution": "720p", "duration": 8}) returns 1.68 ($0.21/s x 8 s).

There's also max_wait_s. Routes expected to take longer than that are skipped, and once that time has passed, no new route is tried. That's useful for interactive features where a clip that arrives in 20 minutes is worthless.

Layer 2: fallback across models

Route-level fallback keeps one model up. Sometimes the model itself is the problem: it refuses a prompt the others accept, or every route is saturated. At that point you want a ranked list of acceptable models, each with its own price cap:

FALLBACK = [
    # (model, input overrides, max_cost_usd)
    ("seedance-2.5", {}, 1.68),
    ("kling-3.0",    {"resolution": "1080p"}, 1.36),
    ("wan-3.0",      {"resolution": "720p"}, 0.56),
]

Two rules make this safe:

1. Only fall back on errors that another model could fix. model_busy, model_unavailable, timeout, all_routes_failed and model_declined are good reasons to try the next model. invalid_input (a bad reference URL) and max_cost_exceeded will fail everywhere, so stop and fix the request. Treat content_policy as a product decision: sometimes another model accepts the prompt, but often you want the refusal to stand.
2. Each fallback is a new intent, so it gets a new idempotency key. The body changes (different model), so reusing the key would be a 409 anyway.

Layer 3: idempotency keys that mean something

The most expensive bug in generation pipelines is the double submit. A worker submits a job, the response is lost (a timeout, a deploy, an OOM kill), the queue redelivers the message, and the worker submits again. Now you've paid twice.

The fix is to derive the key from what you're trying to make, not from the HTTP call:

{job_id}/{shot_id}/{model}/a{attempt}

• After a crash, a redelivered message rebuilds the same key, so the resubmit returns the existing generation and you resume polling it.
• attempt increases only after a generation has reached failed. Failed generations are never charged, so a fresh attempt can't double-bill. Never mint a new key while the previous attempt's status is unknown. Resubmit with the old key and let the server tell you.
• Persist the generation id next to the key as soon as you get it, so a restart can skip straight to polling.

The HTTP layer retries with the same key: 429 (honour Retry-After), 503 busy/model_unavailable, 500, and connection errors. All of those are safe to replay because of the key.

Putting it together

import os, time, requests

API = "https://api.revana.si/v1"
S = requests.Session()
S.headers["Authorization"] = f"Bearer {os.environ['REVANA_API_KEY']}"

RETRY_HTTP = {429, 500, 502, 503, 504}
NEXT_MODEL = {"model_busy", "model_unavailable", "timeout", "all_routes_failed", "model_declined"}

def submit(model, inp, max_cost, key, tries=6):
    body = {"model": model, "input": inp, "max_cost_usd": max_cost}
    for i in range(tries):
        try:
            r = S.post(f"{API}/generations", json=body, headers={"Idempotency-Key": key}, timeout=60)
        except requests.ConnectionError:
            time.sleep(2 ** i); continue                      # same key: safe to replay
        if r.status_code in (200, 202):
            return r.json()
        if r.status_code in RETRY_HTTP:
            time.sleep(float(r.headers.get("Retry-After", 2 ** i))); continue
        err = r.json()["error"]                               # 4xx: retrying won't help
        raise RuntimeError(f"{r.status_code} {err['code']}: {err['message']}")
    raise RuntimeError("gave up submitting")

def wait(gen_id, deadline_s=1800):
    t0, delay = time.time(), 5
    while time.time() - t0 < deadline_s:
        r = S.get(f"{API}/generations/{gen_id}", timeout=30)
        if r.status_code == 200:
            g = r.json()
            if g["status"] in ("succeeded", "failed"):
                return g
        time.sleep(delay); delay = min(delay * 1.5, 30)       # back off on long jobs
    raise TimeoutError(gen_id)

def download(gen_id, path):
    with S.get(f"{API}/generations/{gen_id}/content", stream=True, timeout=300) as r:   # follows the 302
        r.raise_for_status()
        with open(path, "wb") as f:
            for chunk in r.iter_content(1 << 20):
                f.write(chunk)

def make_shot(job_id, shot_id, base_input, fallback, out_path, max_attempts=2):
    for model, overrides, max_cost in fallback:
        inp = {**base_input, **overrides}
        for attempt in range(max_attempts):
            key = f"{job_id}/{shot_id}/{model}/a{attempt}"
            g = wait(submit(model, inp, max_cost, key)["id"])
            if g["status"] == "succeeded":
                download(g["id"], out_path)
                return {"model": model, "id": g["id"], "cost_usd": g["cost_usd"]}
            err = g["error"]
            print(f"{key}: {err['code']} (retryable={err['retryable']}) {err['message']}")
            if err["code"] not in NEXT_MODEL:
                raise RuntimeError(err["message"])            # fix the request, don't burn fallbacks
            if not err["retryable"]:
                break                                         # this model won't do it: next model
            # retryable on this model: one more attempt with a new key (the failed one cost $0)
    raise RuntimeError(f"{shot_id}: every model in the fallback list failed")

if __name__ == "__main__":
    shot = {"prompt": "close-up of hands pouring cold brew over ice, morning light, 9:16 vertical",
            "resolution": "720p", "duration": 8, "aspect_ratio": "9:16", "audio": True}
    print(make_shot("campaign-42", "shot-07", shot, FALLBACK, "shot-07.mp4"))

(FALLBACK is the list from Layer 2. Paste it above __main__.)

Notes on the choices:

• Back off on polling. Generation takes minutes, and polling every second just burns rate limit. Start at 5 s and cap at 30 s.
• 4xx on submit is final. 402 insufficient_credits, 409 idempotency_conflict and 422 invalid_input all need a human or a code change, not a loop.
• cost_usd goes in your ledger, not quoted_usd. If a backup route delivered, the charge can differ from the first quote, though never above max_cost_usd.
• Concurrency. 429 concurrency_limit means too many jobs are in flight. Run the shots through a bounded worker pool (8-16 is plenty) instead of firing 100 at once.

Only paying for what succeeds

The billing model shapes the retry strategy. If a provider charges for failed or timed-out generations, every retry is a gamble, and you end up writing elaborate pre-validation to avoid them. When failures cost $0, as with Revana and ByteDance's own API (which documents charging only successful videos), retrying a model_busy is free, and the only real cost control you need is max_cost_usd per attempt.

The worst case is easy to bound: attempts x max_cost_usd, but only for attempts that succeed, and make_shot stops at the first success. For the fallback list above, a shot costs at most $1.68 (the highest cap in the list), even if all three models are tried.

Before a big batch, check that the account can cover it. GET /v1/balance returns available_usd (what new jobs can reserve) and held_usd (what running jobs are holding):

bal = S.get(f"{API}/balance", timeout=30).json()
need = 100 * FALLBACK[0][2]          # 100 shots at the first model's cap
assert bal["available_usd"] >= need, f"top up: {bal['available_usd']} < {need}"

Checklist

• Price from the live list, cap every request with max_cost_usd.
• Idempotency key = job + shot + model + attempt. Persist the generation id as soon as you have it.
• Replay transport errors, 429, 5xx with the same key. Honour Retry-After.
• New attempt key only after a confirmed failed.
• Fall back to the next model on capacity/timeout errors, not on invalid_input.
• Poll with backoff, download from /content, record cost_usd.
• Bound concurrency, and check available_usd before a batch.

The OpenAPI spec with every error code is at https://revana.si/openapi.json, and live model prices are at GET https://api.revana.si/v1/models. Prices in this post are as of 2026-11-05.

Try it: revana.si has one API key for 200+ video and image models, with live prices on revana.si/pricing.

Disclosure: I work on Revana, one of the APIs compared here. Every number below was read off the sellers' own pages and Revana's live price list on 2026-11-05, and where someone else is cheaper the table says so. Prices in this space change monthly. Re-check them before you commit a budget.

Most "cheapest video API" posts compare one 5-second clip. That hides the things that matter once you ship: per-second rates at the resolution you actually use, whether sound costs extra, and minimums or per-clip pricing that distort short clips.

So here is a more boring and more useful question: what does it cost to make 100 eight-second videos (800 billed seconds) on each API, for the models people actually ask for: Seedance 2.5, Veo 3.1, Kling 3.0, plus Wan 3.0 and one image model, Nano Banana Pro, for reference.

Method

• Clip: 8 seconds, 16:9, with generated audio unless noted. Eight seconds because it is Veo 3.1's maximum and a common ad/social length.
• Sellers: the model maker's own API where one exists (ByteDance's BytePlus ModelArk, Google Vertex AI / Gemini API), plus fal, Replicate, Kie.ai and Revana.
• Prices: list pay-as-you-go prices, no volume deals, no top-up bonuses, no card fees. All are USD, as of 2026-11-05.
• Token-priced sellers (ByteDance, fal for Seedance) are converted with their published formula: tokens = width x height x 24 x seconds / 1024. At 720p 16:9 that is 21,600 tokens per second.
• Per-clip sellers (Kie.ai's Veo 3.1) are divided by the clip length (8 s).

You can check Revana's numbers yourself without a key:

curl -s https://api.revana.si/v1/models \
  | jq '.data[] | select(.id=="seedance-2.5" or .id=="veo-3.1" or .id=="kling-3.0") | {id, price}'

The totals: 100 videos x 8 seconds

Prices as of 2026-11-05. Cheapest per row in bold. A dash means the seller doesn't offer that model or setting.

The per-second rates behind those totals (as of 2026-11-05):

What the table says, model by model

Seedance 2.5: Revana is lowest at both resolutions

At 720p, ByteDance itself (BytePlus ModelArk, $10.70 per million tokens) works out to $0.2311/s for a 16:9 clip, and Replicate passes that rate through almost exactly. Revana is about 9% below them at $0.21/s. Kie.ai is $0.315/s and fal is the outlier at roughly $0.47/s.

At 1080p ByteDance charges a higher token rate ($11.70/M), which works out to about $0.569/s. Revana is $0.52/s. fal now sells 1080p too, at a higher token rate that it puts at about $1.164/s, and Replicate doesn't list 1080p for Seedance 2.5 at all. If your output is 1080p, that difference is $38.88 per 100 clips against ByteDance, $216 against Kie.ai and $515.20 against fal.

Two Seedance details that change the bill more than the headline rate does:

1. Aspect ratio matters on token pricing. fal and ByteDance bill by frame area, so a 21:9 clip costs more per second than a 9:16 one at "the same" resolution. Per-second sellers (Revana, Kie.ai) charge the same for any aspect ratio.
2. Video inputs are billed separately. If you pass a reference clip, most sellers bill the input clip's seconds too, at a different rate. Kie.ai lists $0.085/$0.19/$0.475 per second with video input. Revana lists $0.06/$0.15/$0.34 at 480p/720p/1080p. Replicate's video-input tier is much higher ($0.97/s at 720p).

Veo 3.1: Kie.ai is much cheaper, and I can't explain how

Google's Vertex AI list price for Veo 3.1 with audio is $0.40/s at 720p and 1080p. fal, Replicate and Revana all sell it at exactly that. Kie.ai sells an 8-second 1080p Veo 3.1 clip for 255 credits (about $1.275), which is roughly $0.16/s, or 40% of Google's own price. Their Veo 3.1 Fast is $0.325 per 8-second 1080p clip against Google's $0.96.

If Veo is all you need and you can live with Kie.ai's per-clip packaging, it's the cheapest on this list by a wide margin today. Revana is only slightly below list on Fast ($0.11/s vs Google's $0.12/s at 1080p).

Kling 3.0: Kie.ai first, then fal and Revana tied

Kie.ai is cheapest ($0.151/s Pro with audio). fal ($0.168/s) and Revana ($0.17/s) are effectively tied. Replicate is double ($0.336/s for pro-audio). Note that Replicate charges $0.168/s for Kling 3.0 Standard without audio, so check which variant a page is quoting before comparing.

Wan 3.0: within a few cents

Revana $0.14/s, Kie.ai $0.16/s, fal $0.20/s at 1080p. Over 800 seconds that is $112 vs $128 vs $160. Kie.ai's page notes that reference-video seconds are billed on top of output seconds, and that applies everywhere.

Nano Banana Pro: the biggest spread on the list

For stills (which most video pipelines need for first frames), the spread is wide. Revana is $0.04 per 1K/2K image, Kie.ai $0.09, Google's own Gemini API $0.134, fal and Replicate $0.15. At 4K it's $0.08 / $0.12 / $0.24 / $0.30 / $0.30. If you make storyboards or start frames by the hundred, this line matters more than any video line above.

Costs the rate card doesn't show

Failed generations. Video models refuse prompts, time out, and hit capacity. ByteDance's docs say it charges only for successfully generated videos. Revana does the same: a failed generation's cost_usd is 0. Before you multiply your expected volume by a rate, check each seller's policy on failures, plus your own retry rate. A 10% failure rate on a seller that bills failures is a 10% surcharge.

Minimums and packaging. Per-clip pricing (Kie.ai's Veo) is great for 8-second clips and wasteful if you only need 4. Some sellers also set a per-generation minimum, so read the fine print before you plan a batch of 4-second clips.

Credits vs dollars. Kie.ai sells credits at roughly $0.005 each, with a 10% bonus on larger top-ups. Revana uses 100 credits = $1. Convert everything to dollars before comparing.

Prices move. Several of these pages say prices are "in beta" or "subject to change". Treat the table as a snapshot of 2026-11-05, not a contract.

How to estimate a batch in code before you spend anything

Whichever API you use, compute the cost from the live price list and set a hard cap per job. With Revana that's one unauthenticated call and some arithmetic:

import json, urllib.request

models = {m["id"]: m for m in json.load(urllib.request.urlopen("https://api.revana.si/v1/models"))["data"]}

def clip_cost(model_id, resolution, seconds, audio=False):
    price = models[model_id]["price"]["usd"]
    key = f"{resolution}+audio" if audio and f"{resolution}+audio" in price else resolution
    return round(price[key] * seconds, 4)

for model_id, res, audio in [("seedance-2.5", "1080p", True), ("veo-3.1", "1080p", True), ("kling-3.0", "1080p", True)]:
    one = clip_cost(model_id, res, 8, audio)
    print(f"{model_id:14} {res} 8s: ${one:.2f} per clip, ${one * 100:,.2f} per 100")

Then pass that per-clip figure as max_cost_usd on each request so a single job can never cost more than you planned:

curl -s https://api.revana.si/v1/generations \
  -H "Authorization: Bearer $REVANA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: batch-2026-11-05-clip-001" \
  -d '{
        "model": "seedance-2.5",
        "input": {"prompt": "a paper boat drifting down a rain-soaked street, low angle",
                  "resolution": "1080p", "duration": 8, "aspect_ratio": "16:9", "audio": true},
        "max_cost_usd": 4.16
      }'

Takeaways

• Seedance 2.5: Revana is the lowest list price I found at both 720p ($0.21/s) and 1080p ($0.52/s); ByteDance and Replicate are next at 720p.
• Veo 3.1 and Veo 3.1 Fast: Kie.ai is far below everyone, Google included.
• Kling 3.0: Kie.ai is a little cheaper, with fal and Revana close behind. Replicate's Kling is the most expensive.
• Wan 3.0: Revana is a little cheaper than Kie.ai at 1080p; fal is the most expensive.
• Nano Banana Pro images: Revana at $0.04 is less than half of the next seller.
• No single API wins every row. If you use several models, the real decision is whether one key and one request shape for all of them is worth a few percent on some rows. That's the trade Revana is built around: one POST /v1/generations for 200+ models, charging only for successful generations.

All prices as of 2026-11-05, from: api.revana.si/v1/models; kie.ai/seedance-2-5, /veo-3-1, /kling-3-0, /wan3.0-video, /nano-banana-pro; fal.ai model pages; replicate.com model pages; docs.byteplus.com ModelArk pricing; cloud.google.com Vertex AI pricing; ai.google.dev Gemini API pricing.

Try it: revana.si has one API key for 200+ video and image models, with live prices on revana.si/pricing.

One request shape for every model

Every model, video or image, runs on the same call: POST https://api.revana.si/v1/generations with a model id and an input object. Switching from Seedance to Veo or Kling means changing one string.

Here is a full round trip with the free MiniMax H3 model (video with sound, no credit needed), so you can try it without spending anything:

KEY=$(uuidgen)   # one Idempotency-Key per job

# 1. Submit the job (returns 202 with a generation id)
curl https://api.revana.si/v1/generations \
  -H "Authorization: Bearer $REVANA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d '{
    "model": "minimax-h3-free",
    "input": {
      "prompt": "A street drummer plays on upturned buckets on a busy corner at night, passers-by slowing to watch.",
      "resolution": "768p",
      "aspect_ratio": "9:16",
      "duration": 8
    },
    "max_cost_usd": 0.01
  }'

# 2. Poll until status is "succeeded" or "failed"
curl https://api.revana.si/v1/generations/gen_... \
  -H "Authorization: Bearer $REVANA_API_KEY"

# 3. Download the file
curl -L https://api.revana.si/v1/generations/gen_.../content \
  -H "Authorization: Bearer $REVANA_API_KEY" -o clip.mp4

To run the same prompt on another model, change "model" to seedance-2.5, veo-3.1-fast or kling-3.0 (and raise max_cost_usd). The full list, with each model's options and per-second prices, is at GET /v1/models or revana.si/models.

Know the price before you generate

POST /v1/generations/quote takes the same body and answers what the job will cost (quoted_usd) and the most it can cost (reserved_usd). It is free and creates nothing. Pass the quote as max_cost_usd on the real call and the job will never cost more than that.

Cheapest route first, and failures are free

Most models are sold by several providers at different prices. For each request Revana tries the cheapest healthy route first; if it errors, times out or is full, the next route takes over, so you don't write that retry logic yourself. Only the route that succeeds is charged. A failed generation costs $0.

Resending a request with the same Idempotency-Key after a timeout or a 5xx returns the same generation, so a flaky network never makes you pay twice.

Other ways in

• An MCP server, so Claude or ChatGPT can quote and generate videos for you: revana.si/mcp
• An OpenAI-compatible chat completions endpoint for language models
• A machine-readable summary for agents: revana.si/llms.txt

Billing is prepaid credits: no subscription and no monthly minimum. Docs are at revana.si/docs. If you try it, I'd like to hear what breaks: hello@revana.si.