Videos

Generate a video from a text prompt. The route follows the OpenAI Videos API, so client.videos.create works unchanged with the base URL https://demo-api.routerplus.com/v1.

A video takes from ten seconds to several minutes to make. That is longer than any edge keeps a request open, so each video is a job:

1. 01
   POST /v1/videos answers at once with the job.
2. 02
   GET /v1/videos/{id} reads the job. Repeat until it is completed.
3. 03
   GET /v1/videos/{id}/content downloads the MP4.

To try it without code, pick a video model in the playground.

Limits:

• Replicate serves every video model, on the RouterPlus account. A key bound to your own provider connection cannot make videos.
• Text-to-video only. RouterPlus refuses a request that sends an image input or reference images.

Examples

Each example creates a job, polls it and downloads the MP4.

curl -s https://dev2-api.routerplus.com/v1/videos \
  -H "Authorization: Bearer $TM_API_KEY" -H "content-type: application/json" \
  -d '{"model":"seedance-2.0-fast","prompt":"a paper boat drifting down a rainy street","seconds":"5"}'
# → {"id":"video_…","status":"queued",…}
curl -s https://dev2-api.routerplus.com/v1/videos/video_… -H "Authorization: Bearer $TM_API_KEY"
curl -s https://dev2-api.routerplus.com/v1/videos/video_…/content -H "Authorization: Bearer $TM_API_KEY" -o video.mp4

import os
import time
from openai import OpenAI

client = OpenAI(base_url="https://demo-api.routerplus.com/v1", api_key=os.environ["TM_API_KEY"])

video = client.videos.create(model="wan-3", prompt="a lighthouse at dusk", seconds="5")
while video.status in ("queued", "in_progress"):
    time.sleep(5)
    video = client.videos.retrieve(video.id)
if video.status == "completed":
    client.videos.download_content(video.id).write_to_file("video.mp4")

import { writeFileSync } from "node:fs";
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://demo-api.routerplus.com/v1", apiKey: process.env.TM_API_KEY });

let video = await client.videos.create({ model: "veo-3.1-fast", prompt: "a fox leaping into snow", seconds: "4" });
while (video.status === "queued" || video.status === "in_progress") {
  await new Promise((r) => setTimeout(r, 5000));
  video = await client.videos.retrieve(video.id);
}
if (video.status === "completed") {
  const file = await client.videos.downloadContent(video.id);
  writeFileSync("video.mp4", Buffer.from(await file.arrayBuffer()));
}

The SDK types list OpenAI's own models and lengths. RouterPlus accepts any model id, and any whole number of seconds that the model accepts.

Send your key as Authorization: Bearer tm_vk_... or as x-api-key: tm_vk_.... A missing or invalid key returns 401 with error_type: "auth".

Create a video

POST /v1/videos takes a JSON body of at most 1 MB. RouterPlus checks every rule below before it reserves money or sends anything to a provider. A refused request has no ledger row and no charge.

Each model publishes its accepted values in /api/models.json under supported_parameters. A value outside the set of a model is a 400. The message starts with the field name and lists what that model accepts. An explicit null means "not provided", as on the other routes.

Refused, never dropped: input_reference, frame_images and input_references. A dropped image would make, and bill, a different video from the one you asked for.

Dropped and recorded: any other key, including callback_url. RouterPlus does not send provider webhooks to your URL. The x-tm-dropped-params header and the ledger row name the dropped fields. Send "provider": {"require_parameters": true} to get a 400 instead.

The answer is HTTP 200 with the video object and status: "queued". It carries the same headers as an image response: x-request-id, x-tm-provider, x-tm-attempts, x-tm-upstream-status, and x-tm-dropped-params when a field was dropped. The provider has 60 seconds to accept the job. After that, the request is a 504 upstream_error.

The video object

{
  "id": "video_7f3c2a9b1e4d4c6a8b0f2e1d3c5a7b9e",
  "object": "video",
  "model": "wan-3",
  "status": "completed",
  "progress": 100,
  "created_at": 1790000000,
  "completed_at": 1790000094,
  "expires_at": null,
  "seconds": "5",
  "size": null,
  "resolution": "720p",
  "aspect_ratio": "16:9",
  "error": null,
  "usage": { "cost": 0.5 }
}

Read, list and download

• RouterPlus polls the provider for you: every 5 seconds for the first two minutes, then every 10 seconds, then every 20. A read between two polls shows the last status RouterPlus has.
• A video of another organization is a 404, the same as a video that does not exist.
• The file streams through as it arrives, with the provider's content-type (else video/mp4), content-length, content-range and accept-ranges.
• RouterPlus never stores the file. Save it when you download it.

Billing

RouterPlus bills a video at the provider's listed price for the job: Replicate's published price per second of video, for the seconds Replicate says it billed. That is never more than 5% past the length you asked for. The price passes through with no margin. See Pricing & billing.

Example on wan-3 (per-second ceiling $0.105): a 5-second request reserves $0.525 (5 × $0.105). At 480p, Replicate bills $0.025 a second, so the charge is $0.125. RouterPlus releases the rest of the hold.

Models

• Wan 3 and Grok Imagine Video follow the provider's audio defaults. This API has no audio toggle for them.
• Prices are Replicate's published prices for each model, read on 2026-10-12.
• Replicate bills the video it returned. That can run a fraction of a second past the length you asked for (5.04 s for 5 s). The fraction is billed, up to 5% of the length.
• Sora 2 was retired on September 24, 2026. Existing video and usage records stay readable. See OpenAI’s discontinuation notice.

Errors

Error bodies use the OpenAI error envelope, with the canonical class in error.metadata.error_type. RouterPlus never relays a provider's own error body. A video model sent to POST /v1/chat/completions, POST /v1/messages or POST /v1/images/generations is a 400 that names /v1/videos.

Data policy

RouterPlus keeps the id, model, length, shape, status and charge of a job, so you can retrieve it later. The video file streams from the provider when you download it. See Data policy.

Model discovery

curl -s "https://demo-api.routerplus.com/v1/models?output_modalities=video" \
  -H "Authorization: Bearer $TM_API_KEY"

Every row of GET /v1/models carries architecture.output_modalities, for example ["video"]. For each video model, the public feed https://demo.routerplus.com/api/models.json carries:

• supported_parameters
• max_output_tokens: the per-second ceiling in cost units (one micro-dollar each)
• price_card: the provider's listed prices

See also: POST /v1/images/generations · Pricing & billing · Errors