Video Generation - Mesh API

Give Mesh a prompt and you get back a video. Give it more to work with — a still to open on, a second still to end on, reference images, a clip, a soundtrack — and you get back a video that matches what you supplied. Generating a video takes minutes rather than seconds, so this endpoint is asynchronous. Your POST returns a task ID straight away, and the finished video arrives either when you ask for it or through a webhook. Everything goes to https://api.meshapi.ai and carries your API key as Authorization: Bearer rsk_<your-key>. See Authentication if you need one.

Your first video

A prompt in, a task ID out.

curl
Python
Node.js

curl -X POST https://api.meshapi.ai/v1/video/generations \
  -H "Authorization: Bearer rsk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "byteplus/dreamina-seedance-2-0",
    "content": [
      { "type": "text", "text": "A cinematic drone shot over a misty mountain valley at dawn" }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5
  }'

import requests

res = requests.post(
    "https://api.meshapi.ai/v1/video/generations",
    headers={"Authorization": "Bearer rsk_YOUR_KEY"},
    json={
        "model": "byteplus/dreamina-seedance-2-0",
        "content": [
            {"type": "text", "text": "A cinematic drone shot over a misty mountain valley at dawn"}
        ],
        "resolution": "1080p",
        "ratio": "16:9",
        "duration": 5,
    },
)
task = res.json()
print(task["id"], task["status"])

const res = await fetch("https://api.meshapi.ai/v1/video/generations", {
  method: "POST",
  headers: {
    Authorization: "Bearer rsk_YOUR_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "byteplus/dreamina-seedance-2-0",
    content: [
      { type: "text", text: "A cinematic drone shot over a misty mountain valley at dawn" },
    ],
    resolution: "1080p",
    ratio: "16:9",
    duration: 5,
  }),
});
const task = await res.json();
console.log(task.id, task.status);

The response is short, because there is no video yet:

{
  "id": "t-xxxxxxxxxxxxxxxx",
  "status": "queued",
  "unsupported_params": null
}

Hold on to that id — Getting the result turns it into a video. Log unsupported_params beside it while you are there: this is the only response that ever carries it, and it tells you whether the request that ran was the request you sent. Three endpoints cover everything on this page:

Method	Path	What it does
`POST`	`/v1/video/generations`	Start a generation
`GET`	`/v1/video/generations/{id}`	Check one task and collect its video
`GET`	`/v1/video/generations`	List your recent tasks

The examples further down show the request body only. Send each of them exactly like the curl above — same URL, same two headers.

Giving the model something to work from

The content array carries your prompt and every piece of media that goes with it. Each item says two separate things:

type is the modality — text, image_url, video_url, audio_url or document_url.
role is what that media is for — first_frame, last_frame, reference_image, reference_video, reference_audio or reference_document (plus the finer roles below).

Keeping them apart is what lets one request carry two images that mean different things. Two image_url items are ambiguous on their own; a first_frame and a last_frame are not.

`type`	Where the payload goes
`text`	`text` — your prompt
`image_url`	`image_url.url`
`video_url`	`video_url.url`
`audio_url`	`audio_url.url`
`document_url`	`document_url.url`: a public URL the model reads for reference
`draft_task`	`draft_task.id` — see Preview first, then render

Any of the URLs may be a publicly reachable link or a Base64 data URI (data:image/jpeg;base64,... — keep the MIME prefix). A public URL has to be fetchable without authentication, since the model fetches it itself. role is optional. Leave it out and each item falls back to its most common meaning:

Item with no `role`	Read as
`image_url`	`first_frame`
`video_url`	`reference_video`
`audio_url`	`reference_audio`
`document_url`	`reference_document`

So the simplest image-to-video request needs no role at all. You need one as soon as a request pins a closing frame, or uses images as references rather than as frames. A role that contradicts its item — first_frame on an audio item — is rejected with 422. So is a role the model you picked does not offer: rather than drop the item and generate something you did not ask for, the submit refuses it and names the offending entry — by its position in content on most models, by role alone on the rest. Neither costs you a generation, but both cost you a round trip — check first.

Pick one input scenario, not two

Roles are not freely combinable. A request is one of these shapes, and on most models they are mutually exclusive:

Scenario	What you send
Text to video	A prompt, no media
First frame	One image, optional prompt
First and last frame	Two images, optional prompt
References	Reference images, a clip and/or audio, optional prompt

Mixing two of them is the most common way a video request fails. A first_frame alongside a reference_image is not a richer request — it is an invalid one, and you often find out late: the submit returns 200 with a task ID and the task goes failed minutes later.

To pin both ends and supply references, use first-and-last-frame — it is the only shape that guarantees the output matches the images you gave. References can be nudged toward a particular opening with wording in the prompt, but nothing guarantees the match. Text to video is not universal either: a model published specifically for image-to-video or for upscaling needs its input media and turns down a prompt-only request with a 400.

Start from an image

One image and a prompt: the video opens on your still and moves from there. role is optional here, but writing it makes the intent obvious.

{
  "model": "byteplus/dreamina-seedance-2-0",
  "content": [
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/first-frame.jpg" },
      "role": "first_frame"
    },
    { "type": "text", "text": "The subject slowly turns and walks toward the camera" }
  ],
  "duration": 5,
  "ratio": "9:16",
  "seed": 42
}

Open and close on exact frames

Give the model both ends and it fills in the middle. Here role is required — two images with no roles are ambiguous.

{
  "model": "byteplus/dreamina-seedance-2-0",
  "content": [
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/open.jpg" },
      "role": "first_frame"
    },
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/close.jpg" },
      "role": "last_frame"
    },
    { "type": "text", "text": "The camera pushes in slowly as the light shifts from dawn to midday" }
  ],
  "duration": 5,
  "ratio": "adaptive"
}

The two images may be identical, and they need not share an aspect ratio — the first frame wins and the last frame is cropped to match. A closing frame is a rarer ability than an opening one, and models that offer it usually want a first_frame with it.

Work from reference images

References say what should appear, not where in time it appears — a face, a product, a look. Use them when you want the same thing to show up in the video without dictating any particular frame.

{
  "model": "byteplus/dreamina-seedance-2-5",
  "content": [
    { "type": "text", "text": "A product reveal with dramatic lighting, matching the reference style" },
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/product.jpg" },
      "role": "reference_image"
    },
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/lighting-mood.jpg" },
      "role": "reference_image"
    }
  ],
  "duration": 8,
  "ratio": "adaptive"
}

How many reference images you may send ranges from one to thirty depending on the model. supports_video_reference_image tells you whether the role is accepted at all; the model governs how many.

Name your subjects

A flat list of five reference images is five unrelated references — nothing in it says that the first two are the same person and the third is the bottle she picks up. subject says so. Pick a name, put it on every item that shows that subject, and refer to it in the prompt as @name.

{
  "model": "kling/kling-3.0-omni",
  "content": [
    { "type": "text", "text": "@hero picks up @bottle and turns toward the window" },
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/hero-front.jpg" },
      "role": "reference_image",
      "subject": "hero"
    },
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/hero-profile.jpg" },
      "role": "reference_image",
      "subject": "hero"
    },
    {
      "type": "image_url",
      "image_url": { "url": "https://example.com/bottle.jpg" },
      "role": "reference_image",
      "subject": "bottle"
    }
  ],
  "duration": 5,
  "ratio": "adaptive"
}

Four things to know:

Order matters inside a group: the first item is the main view, the rest are further angles of the same subject. Nothing about the request looks ordered, which is what makes this easy to get wrong — put the clearest, most head-on image first.

Names are strict and match exactly. 1–64 characters of letters, digits, underscore or hyphen. Spaces, @, dots and non-ASCII are rejected with a 422, as is an empty name, and matching is case-sensitive — Hero and hero are two different subjects. In the prompt, only names you actually declared are treated as citations; every other @ in your text is left exactly as you typed it. subject belongs on reference items only. On a first_frame, on a text item, or anywhere else it returns 422. Grouping never costs you anything. A model with no notion of subjects still receives every image as an ordinary reference, so the request above works wherever reference images do — it simply loses the distinction between the two subjects. You never need two versions of a request.

Not every model reads names. Some match reference images by the order you sent them instead, and there an @name is just text in your prompt — the images still reach the model, you only lose which-is-which. Describing your subjects in prose as well (“the man in the blue coat picks up the green bottle”) costs nothing and reads correctly either way.

Keeping a character consistent

Models that can hold one character across a whole video generally screen the reference first, for likeness and for copyright, and decline anything that looks like a real person. That screening is the usual reason a reference which “should” work appears to have been ignored. Where a model works that way, Mesh registers your reference before generating so the same face survives from shot to shot. There is nothing to switch on — send the image as a public URL or a data URI exactly as you would otherwise.

The first request with a brand-new reference can come back 422, saying the reference is still being prepared. Registration runs in the background with no fixed completion time. Retry the same request; the retry joins the registration already in flight rather than starting a second one, and after that the image is immediate.

References are matched on content, not on URL. The same image behind a re-signed link or a CDN variant is one reference, so changing the URL of an image you have already used costs nothing. Send the image, not an ID. asset:// identifiers from elsewhere are rejected with 422. Supply a URL or a data URI and Mesh does the registering.

By supplying a reference you confirm you hold the rights to it and that it is not the likeness of a real person. Registered references are kept while you keep using them and removed once you stop. See the Terms of Service.

Work from a clip

A reference_video is a clip for the model to imitate, edit or extend — motion, pace, framing, or the footage itself.

{
  "model": "byteplus/dreamina-seedance-2-5",
  "content": [
    { "type": "text", "text": "Keep the camera move but restage it at night in the rain" },
    {
      "type": "video_url",
      "video_url": { "url": "https://example.com/clip.mp4" },
      "role": "reference_video"
    }
  ],
  "ratio": "adaptive"
}

Fewer models take a clip than take an image, so check supports_video_reference_video first. To raise the resolution of an existing video rather than reimagine it, see Upscale an existing video.

Work from a soundtrack

A reference_audio item gives the model audio to follow — a beat to cut to, a voice to match a mouth to.

{
  "model": "byteplus/dreamina-seedance-2-5",
  "content": [
    { "type": "text", "text": "A dancer in a bare studio, moving in time with the music" },
    {
      "type": "audio_url",
      "audio_url": { "url": "https://example.com/soundtrack.mp3" },
      "role": "reference_audio"
    }
  ],
  "duration": 8,
  "ratio": "adaptive"
}

Audio is the least widely supported input of the three — supports_video_reference_audio is the flag. Some models also will not take audio as the only media in a request; if one turns this down, send a reference image or a clip alongside it.

Upscale an existing video

Upscalers take a video and return a higher-resolution one. The request is a different shape: the source clip is the only input, and a prompt, ratio, duration or frames are not accepted.

curl -X POST https://api.meshapi.ai/v1/video/generations \
  -H "Authorization: Bearer rsk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bytedance/bytedance-video-upscaler",
    "content": [
      { "type": "video_url", "video_url": { "url": "https://example.com/clip.mp4" } }
    ]
  }'

Collect the result exactly as with any other task. A video_url item is required — a prompt on its own returns 400, because there is nothing to upscale. The target resolution is fixed by the model, so resolution does not change the output, but it does pick the per-second price tier you are billed at (720p when omitted).

Finer roles, documents and keyframes

Three roles narrow an ordinary reference role to a slot a few models define. A model without the finer slot still receives the media as the role it narrows, so naming one never costs you a route:

Role	Narrows	For
`scene_image`	`reference_image`	A picture of the scene or setting
`source_video`	`reference_video`	The clip an edit works on. Required for `match_source_duration`
`background_audio`	`reference_audio`	A music bed

reference_document (on a document_url item) narrows nothing: a model that cannot read a document refuses the request rather than generating without it. A reference_image can be pinned to one moment of the video with frame_index (a frame number, counting from 0) or timestamp (seconds from the start), one image per moment. The units are not interchangeable: each reaches only the models that define it, and a model with no keyframe concept still receives the image as an ordinary reference.

What you can send

The ceilings below are the widest any current model allows. A given model may be tighter, so treat a refusal that names a size, a duration or a count as that model’s limit rather than the platform’s. Images — jpeg, png, webp, bmp, tiff, gif, and heic/heif on some models. Each side 300–6000 px, aspect ratio between 0.4 and 2.5, up to 30 MB each. One image for a first frame, two for first-and-last, up to 30 references. Clips — mp4 or mov, H.264/AVC or H.265/HEVC video with AAC or MP3 audio, 24–60 fps. Each side 300–6000 px, aspect ratio 0.4–2.5, up to 200 MB and 2–30 s each, up to 10 clips totalling 30 s. An edit job needs at least 4 s to work from. Audio — wav or mp3, up to 15 MB and 2–30 s each, up to 10 clips totalling 30 s.

The whole request body has a hard 32 MiB ceiling (33,554,432 bytes) on every Mesh endpoint, enforced at the edge — an oversized request never reaches the API and comes back as a plain HTML 413 Request Entity Too Large page rather than a Mesh error. See Rate Limits & Spend Caps.So do not Base64-encode large files: encoding inflates a payload by about a third, and a ~24 MB file already breaks the body limit on its own. Public URLs are the only way to reach the per-file caps above.

Older spellings

Before role existed, the purpose went in type — "type": "first_frame" and friends. Those requests still work and still mean what they meant, so nothing you already send needs changing. Write new ones with the modality in type and the purpose in role: the older form is read as the role it always meant, so an item the model cannot take is refused with a 422 either way. The modern spelling is the one that works everywhere.

Shaping the output

Everything on this page other than model and content is an optional top-level field. Mesh sets no default for any of them — omitted means absent, not “the model’s default”.

A field name this endpoint does not recognise is dropped without a word. There is no 422 and no warning: the request returns 200, the task runs, and your parameter was never part of it. A typo like negitive_prompt, or aspect_ratio where the field is ratio, costs you a whole generation before you notice. Check your spelling against the tables below.Sending a real field to a model that does not implement it is a different case, and that one you do hear about — see What the route dropped.

The basics

Field	Type	Description
`resolution`	string	Output resolution, e.g. `720p`, `1080p`, or an exact pixel size, `1280x720` or `1280720`, on the models that take one (the Size* column below).
`ratio`	string	Aspect ratio, e.g. `16:9`, `9:16`, `1:1`. `adaptive` follows your input media.
`duration`	integer	Target length in seconds, 1–300.
`match_source_duration`	boolean	Make the video as long as the `source_video` clip you sent. Needs exactly one `source_video` item; cannot be combined with `duration`.
`frames`	integer	A frame count instead of a duration, for sub-second lengths. Only some models take it. Send it or `duration`, not both.
`generate_audio`	boolean	Generate an audio track alongside the video. Priced differently when on.
`return_last_frame`	boolean	Also return a still of the final frame, handy as the opening frame of the next clip.
`seed`	integer	Fix the seed to make a generation reproducible.
`camera_fixed`	boolean	Lock the camera — no camera movement.
`watermark`	boolean	Add a watermark to the output.
`draft`	boolean	Render a fast preview instead of the finished video. See Preview first, then render.
`callback_url`	string	Where to POST the finished task. BytePlus, Kling and MiniMax models only; any other model returns `422`. See Have the result delivered.
`service_tier`	string	Ask for a particular service tier, where the model offers a choice.
`execution_expires_after`	integer	Seconds before an unfinished task gives up. BytePlus models only. Default `172800` (48 hours).
`priority`	integer 0–9	How urgent this job is. Higher is more urgent.
`safety_identifier`	string	A stable, anonymised id for the end user the request was made for, used for abuse detection.
`previous_task_id`	string	Edit one of your own earlier `succeeded` videos instead of uploading it again. Describe the change in a `text` item. Token-priced Gemini Omni Flash models only (`google/gemini-omni-flash-preview`); anything else returns `422`.
`external_task_id`	string	Your own id for the task, forwarded to Kling so the task is findable by your identifier. Ignored elsewhere.
`fast_pretreatment`	boolean	MiniMax Hailuo: skip some prompt pre-processing so generation starts sooner.
`tags`	object	Your own labels, as an object of up to 16 string pairs. Filter and group spend by them in usage reports.

Finer control

These shape how the model generates rather than what comes out of the pipe. Support varies by model, which is the whole reason for the capability flags.

Field	Type	Values	What it does
`negative_prompt`	string	—	What to keep out of the video. The length cap varies; 2500 characters is a safe assumption.
`guidance_scale`	number	`1.0`–`10.0`	How literally to follow your prompt versus inventing freely. Higher is more literal. Outside the range is a `422`.
`prompt_extend`	boolean	—	Let the model flesh out your prompt with detail before generating. Helps short prompts, costs time.
`style`	string	`general`, `anime`	Visual style of the output.
`movement_amplitude`	string	`auto`, `small`, `medium`, `large`	How much the subjects in frame are allowed to move.
`multi_shot`	boolean	—	Let the model cut between camera angles instead of holding one shot.
`thinking_level`	string	`default`, `low`, `high`	How hard the model thinks about your prompt before generating. Higher is slower.
`num_inference_steps`	integer	`1`–`100`	Denoising steps. More steps, more detail, longer wait. Outside the range is a `422`.
`web_search`	boolean	—	Let the model look things up while generating, for prompts about something current. Adds latency.
`bgm`	boolean	—	Add background music to the generated audio.
`keep_original_sound`	boolean	—	Keep the audio from your reference clip instead of generating new audio.
`audio_type`	string	`all`, `speech_only`, `sound_effect_only`	Which parts of the audio track to generate. Only meaningful with `generate_audio: true`.
`output_format`	string	e.g. `mp4`, `mov`	Output container. `mp4` plays everywhere; `mov` carries higher colour precision for grading, compositing, or as the input to a later edit. The values that mean anything are the model’s.
`bitrate_mode`	string	`standard`, `high`	`high` encodes at a higher bitrate — crisper picture, bigger file.
`enable_safety_checker`	boolean	—	Run a safety check on the output. Turning it off can return unsafe content.
`omni_reference_task_type`	string	`auto`, `reference`, `edit`, `extend`	Which reference job you meant. See Say which reference job you mean.

guidance_scale and num_inference_steps are the only two values Mesh range-checks. Every other field above is forwarded exactly as you wrote it, so the values listed are the ones that mean something to the models implementing that field, not a set Mesh polices. Send output_format: "webm" and you will not get a 422 from us — you get whatever the model makes of an unfamiliar container, which may be an error and may be nothing at all.

negative_prompt is the least predictable of these. Support varies model by model rather than in tidy families — two builds of the same family often differ — which is why it has a capability flag of its own. If a video plainly ignored your negative prompt, read supports_video_negative_prompt before you start rewording it.

Say which reference job you mean

Some models can do several different jobs from reference material: generate something new, edit an existing clip, or extend one. Each job has its own constraints, and if you let the model guess which one you meant, a request whose parameters contradict its guess is accepted and fails minutes later. omni_reference_task_type names the job so the constraints are checked at submit instead:

Value	The job	Checked when you submit
`auto` (default)	The model infers it from your media and prompt	Nothing — a mismatch fails later
`reference`	Generate a new video from references	No extra constraints
`edit`	Change the picture or audio of an existing clip	Needs a `reference_video`; `ratio` must be `adaptive` or omitted; `duration` must be omitted
`extend`	Continue an existing clip	Needs a `reference_video`; `ratio` must be `adaptive` or omitted

omni_reference_task_type is a Seedance 2.5 parameter (e.g. byteplus/dreamina-seedance-2-5); other Seedance models return 422. The model’s own limits, such as an edit source clip of 4–30 s, are still checked by the model after you submit. Naming the job is worth it even when you are confident: the failure you avoid is the expensive kind to debug.

{
  "model": "byteplus/dreamina-seedance-2-5",
  "content": [
    { "type": "text", "text": "Continue the shot as the car disappears around the corner" },
    {
      "type": "video_url",
      "video_url": { "url": "https://example.com/clip.mp4" },
      "role": "reference_video"
    }
  ],
  "omni_reference_task_type": "extend",
  "ratio": "adaptive"
}

The model still re-reads your prompt when it runs. If it decides you asked for a different job than the one you named, the task fails anyway — so keep the prompt consistent with the job.

Preview first, then render

draft: true renders a fast, rough version of the same request. When you like one, send its task ID back as a draft_task item and the model renders it properly instead of generating something new from scratch.

{
  "model": "byteplus/dreamina-seedance-2-0",
  "content": [
    { "type": "draft_task", "draft_task": { "id": "t-xxxxxxxxxxxxxxxx" } }
  ]
}

Finding out what a model accepts

Video models differ far more than text models do — one takes a closing frame, the next has no concept of one. Two fields answer the question: one before you send, one after.

Check the flags before you send

GET /v1/models returns a capability flag per input, at the top level of each model entry beside supports_tools and the rest. Read them at runtime rather than keeping a list of your own: support genuinely changes between two builds of the same family.

curl "https://api.meshapi.ai/v1/models?type=video" \
  -H "Authorization: Bearer rsk_YOUR_KEY" \
  | jq '.[] | select(.supports_video_last_frame) | .id'

Start with supports_video_generation, which says the model makes video at all. These six then describe what it takes in:

Flag	`true` when the model accepts
`supports_video_first_frame`	`role: "first_frame"` — an opening image
`supports_video_last_frame`	`role: "last_frame"` — a pinned closing frame
`supports_video_reference_image`	`role: "reference_image"`
`supports_video_reference_video`	`role: "reference_video"`
`supports_video_reference_audio`	`role: "reference_audio"`
`supports_video_negative_prompt`	the `negative_prompt` parameter

Five of the six are named for a content role. The last one is not — it is named for the top-level negative_prompt parameter, and there is no negative_prompt role to put on a content item.

All six read false on every model that is not a video model. An all-false set almost never means “a video model that accepts no input” — it means you are not looking at a video model. Check supports_video_generation first; the other six only mean something once it is true.

A model can be served by more than one route, and the flags can differ between them. GET /v1/models reports the route you are most likely to get; GET /v1/models/{model_id}/providers returns the same six for every route that can serve the model. So the model entry answers “will the route I am likely to get take a last frame”, and the providers endpoint answers “does any route take one”.

curl https://api.meshapi.ai/v1/models/byteplus/dreamina-seedance-2-5/providers \
  -H "Authorization: Bearer rsk_YOUR_KEY"

The full field list is on Models.

What each model accepts

The flags say WHICH inputs a model takes. This says which VALUES its parameters accept — the resolutions it renders, how long a clip may be, the aspect ratios it offers, and how many media items you may attach. Read it before sizing a request: a value a model does not render is a 422 at submit, and a parameter it does not implement is dropped and named in unsupported_params.

Model	Resolution	Size	Duration	Aspect ratio	Max media inputs
`alibaba/happyhorse-1.0`	`720p`, `1080p`	—	—	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`alibaba/happyhorse-1.1`	`480p`, `720p`, `1080p`	—	—	`16:9`, `1:1`, `21:9`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`	—
`alibaba/wan-2.5`	`480p`, `720p`, `1080p`	`10801920`, `1088832`, `12481632`, `1280720`, `14401440`, `16321248`, `19201080`, `480832`, `624624`, `7201280`, `8321088`, `832480`, `960*960`	5–10s	—	—
`alibaba/wan-2.6`	`720p`, `1080p`	`10801920`, `1088832`, `12481632`, `1280720`, `14401440`, `16321248`, `19201080`, `7201280`, `8321088`, `960960`	5s, 10s, 15s	—	—
`alibaba/wan-2.7`	`720P`, `1080P`	—	—	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`alibaba/wan-3.0`	`720p`, `1080p`	—	2–30s	—	frames ×2, ref audio ×5, ref images ×10, ref videos ×5
`alibaba/wan-3.0-prime`	`720p`, `1080p`	—	2–30s	—	frames ×2, ref audio ×5, ref images ×10, ref videos ×5
`atlascloud/van-2.5`	`720p`, `1080p`	`10801920`, `1280720`, `19201080`, `7201280`	5s, 10s	—	—
`atlascloud/van-2.6`	`1080p`	`10801920`, `12481632`, `14401440`, `16321248`, `1920*1080`	5s, 10s, 15s	—	—
`atlascloud/wan-2.2-turbo`	`480p`, `720p`, `1080p`	—	5s	—	—
`bytedance/seedance-1.0-lite` _{ignores resolution, ratio}	—	—	1–10s	—	—
`bytedance/seedance-1.0-pro`	—	—	2–12s	—	—
`bytedance/seedance-2.0`	`480p`, `720p`, `720p-SR`, `1080p`, `1080p-SR`, `1440p-SR`, `4k`	—	4–15s · `auto`	`16:9`, `1:1`, `21:9`, `3:4`, `4:3`, `9:16`, `adaptive`	—
`bytedance/seedance-2.0-fast`	`480p`, `720p`, `720p-SR`, `1080p-SR`, `1440p-SR`	—	4–15s · `auto`	`16:9`, `1:1`, `21:9`, `3:4`, `4:3`, `9:16`, `adaptive`	—
`bytedance/seedance-2.0-mini`	`480p`, `720p`, `720p-SR`, `1080p-SR`, `1440p-SR`	—	4–15s · `auto`	`16:9`, `1:1`, `21:9`, `3:4`, `4:3`, `9:16`, `adaptive`	—
`byteplus/dreamina-seedance-2-0`	—	—	4–15s	—	—
`byteplus/dreamina-seedance-2-0-fast`	—	—	4–15s	—	—
`byteplus/dreamina-seedance-2-5`	—	—	4–30s	—	—
`byteplus/seedance-1-0-pro-fast`	—	—	2–12s	—	—
`byteplus/seedance-1-5-pro`	—	—	4–12s	—	—
`character-ai/ovi` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`fastvideo/fastwan-qad-fp8-1.3b`	`480p`	—	5s	—	—
`google/gemini-omni-flash`	`720p`, `1080p`, `4k`	—	4s, 6s, 8s, 10s	`16:9`, `9:16`	—
`google/gemini-omni-flash-preview` _{values are provider-wide, not specific to this model}	`360p`, `720p`, `1080p`, `4k`	—	—	`16:9`, `9:16`	—
`google/gemini-omni-flash-video` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`google/veo-3.0` _{ignores resolution, ratio}	—	—	1–10s	—	—
`google/veo-3.0-fast` _{ignores resolution, ratio}	—	—	1–10s	—	—
`google/veo-3.1`	`720p`, `1080p`	—	—	`16:9`, `9:16`	—
`google/veo-3.1-fast`	`720p`, `1080p`	—	—	`16:9`, `9:16`	—
`google/veo3.1-lite`	`720p`, `1080p`	—	4s, 6s, 8s	`16:9`, `9:16`	—
`heygen/heygen-avatar-iv`	`720p`, `1080p`	—	—	—	—
`heygen/heygen-avatar-v`	`720p`, `1080p`	—	—	—	—
`heygen/heygen-video-agent`	—	—	5–300s	—	—
`kling/kling-1.0` _{ignores resolution}	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-1.5` _{ignores resolution}	—	—	5s, 10s	—	—
`kling/kling-1.6` _{ignores resolution}	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-2.0-master` _{ignores resolution}	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-2.1-master` _{ignores resolution}	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-2.1-pro` _{ignores resolution, ratio}	—	—	1–10s	—	—
`kling/kling-2.5-turbo` _{ignores resolution}	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-2.5-turbo-pro`	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-2.6` _{ignores resolution}	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-2.6-pro`	—	—	5s, 10s	`16:9`, `1:1`, `9:16`	—
`kling/kling-3.0` _{ignores resolution}	—	—	3–15s	`16:9`, `1:1`, `9:16`	—
`kling/kling-3.0-omni`	`720p`, `1080p`, `4k`	—	3–15s	—	—
`kling/kling-3.0-turbo`	`720p`, `1080p`	—	3–15s	—	—
`kling/kling-o3-4k` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`kling/kling-o3-pro` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`kling/kling-o3-standard` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`kling/kling-v3-standard` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`kling/kling-v3-turbo-pro` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`kling/kling-v3-turbo-standard` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`kling/kling-v3.0-4k`	—	—	3–15s	`16:9`, `1:1`, `9:16`	—
`kling/kling-v3.0-pro`	`1080P`, `1440P-SR`	—	3–15s	`16:9`, `1:1`, `9:16`	—
`kling/kling-v3.0-std`	`720P`, `1080P-SR`, `1440P-SR`	—	3–15s	`16:9`, `1:1`, `9:16`	—
`kling/kling-video-o1`	`720p`, `1080p`	—	5s, 10s	—	—
`kling/kling-video-o3-4k`	—	—	3–15s	`16:9`, `1:1`, `9:16`	—
`kling/kling-video-o3-pro`	—	—	3–15s	`16:9`, `1:1`, `9:16`	—
`kling/kling-video-o3-std`	—	—	3–15s	`16:9`, `1:1`, `9:16`	—
`klingai/kling-video-2-6-pro`	—	—	5s, 10s	—	frames ×2, ref images ×1, ref videos ×1
`klingai/kling-video-2-6-standard`	—	—	—	—	ref images ×1, ref videos ×1
`klingai/kling-video-3-0-4k`	—	—	3–15s	—	frames ×2
`klingai/kling-video-3-0-omni-4k`	—	—	3–15s	—	frames ×2, ref videos ×1
`klingai/kling-video-3-0-omni-pro`	`1080p`	—	3–15s	—	frames ×2, ref images ×7, ref videos ×1
`klingai/kling-video-3-0-omni-standard`	`720p`	—	3–15s	—	frames ×2, ref images ×7, ref videos ×1
`klingai/kling-video-3-0-pro`	—	—	3–15s	—	frames ×2, ref images ×1, ref videos ×1
`klingai/kling-video-3-0-standard`	—	—	3–15s	—	frames ×2, ref images ×1, ref videos ×1
`klingai/kling-video-3-0-turbo`	`720p`, `1080p`	—	3–15s	—	frames ×1
`klingai/kling-video-o1-pro`	—	—	—	—	frames ×2, ref images ×7, ref videos ×1
`klingai/kling-video-o1-standard`	—	—	—	—	frames ×2, ref images ×7, ref videos ×1
`klingai/klingai-1-5-pro`	—	—	5s, 10s	—	frames ×2
`klingai/klingai-1-6-standard`	—	—	5s, 10s	—	frames ×1
`klingai/klingai-2-0-master`	—	—	5s, 10s	—	frames ×2
`klingai/klingai-2-1-master`	—	—	5s, 10s	—	frames ×1
`klingai/klingai-2-1-pro`	—	—	5s, 10s	—	frames ×2
`klingai/klingai-2-1-standard`	—	—	5s, 10s	—	frames ×1
`klingai/klingai-2-5-turbo-pro`	—	—	5s, 10s	—	frames ×2
`klingai/klingai-2-5-turbo-standard`	—	—	5s, 10s	—	frames ×1
`lightricks/ltx-2-19b` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`lightricks/ltx-2-19b-distilled` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`lightricks/ltx-2-fast` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`lightricks/ltx-2-full` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`lightricks/ltx-2.3-fast` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`lightricks/ltx-2.3-full` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`luma/ray3-2`	`720p`, `1080p`	—	5s, 10s	—	frames ×64
`meituan/longcat-video-distilled` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`minimax/hailuo-02`	`512P`, `768P`, `1080P`	—	6s, 10s	—	—
`minimax/hailuo-2.3`	`768P`, `1080P`	—	6s, 10s	—	—
`minimax/minimax-01-live`	—	—	—	—	frames ×1
`minimax/minimax-h3`	—	—	5–15s	—	frames ×2, ref audio ×3, ref images ×9, ref videos ×3
`minimax/video-01-director` _{ignores resolution, ratio}	—	—	1–10s	—	—
`openai/sora-2` _{ignores resolution, ratio}	—	—	1–10s	—	—
`pixverse/pixverse-6-i2v`	—	—	1–15s	—	—
`pixverse/pixverse-6-t2v`	—	—	1–15s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `9:16`	—
`pixverse/pixverse-c1` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`pixverse/pixverse-lipsync`	—	—	—	—	ref videos ×1
`pixverse/pixverse-modify`	`720p`	—	—	—	ref images ×3
`pixverse/pixverse-v3-5`	`720p`, `1080p`	—	5s, 8s	—	frames ×2
`pixverse/pixverse-v4`	`720p`, `1080p`	—	5s, 8s	—	frames ×2
`pixverse/pixverse-v4-5`	`720p`, `1080p`	—	5s, 8s	—	frames ×2
`pixverse/pixverse-v5` _{ignores resolution, ratio}	—	—	1–10s	—	—
`pixverse/pixverse-v5-5`	`720p`, `1080p`	—	—	—	frames ×2
`pixverse/pixverse-v5-fast`	`720p`, `1080p`	—	5s, 8s	—	frames ×1
`pixverse/pixverse-v5.6` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`prunaai/p-video`	`720p`, `1080p`	—	1–10s	`16:9`, `1:1`, `2:3`, `3:2`, `3:4`, `4:3`, `9:16`	—
`prunaai/p-video-animate`	`720p`, `1080p`	—	—	—	ref images ×1, ref videos ×1
`prunaai/p-video-avatar`	`720p`, `1080p`	—	—	—	frames ×1
`prunaai/p-video-replace`	`720p`, `1080p`	—	—	—	ref images ×3
`runway/runway-aleph-2-0`	—	—	—	—	frames ×5
`runwayml/gen-4-turbo` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`runwayml/gen-4.5` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`skywork/skyreels-v4`	`720p`, `1080p`	—	3–15s	—	frames ×8, ref images ×3, ref videos ×1
`veed/fabric-1.0`	`480p`, `720p`	—	—	—	—
`veed/fabric-1.0/fast`	`480p`, `720p`	—	—	—	—
`venice/wan-2.7-uncensored` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`vidu/q1`	`1080p`	—	—	`16:9`, `1:1`, `9:16`	—
`vidu/q2`	`540p`, `720p`, `1080p`	—	—	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`vidu/q2-pro-fast`	`720p`, `1080p`	—	—	—	—
`vidu/q3`	`540p`, `720p`, `1080p`, `1080p-sr`, `1440p-sr`	—	—	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`vidu/q3-pro`	`540p`, `720p`, `1080p`, `1080p-sr`, `1440p-sr`	—	—	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`vidu/q3-turbo`	`540p`, `720p`, `1080p`, `1080p-sr`, `1440p-sr`	—	—	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`vidu/vidu-q1` _{ignores resolution, ratio}	—	—	1–10s	—	—
`vidu/vidu-q1-classic`	—	—	—	—	frames ×2
`vidu/vidu-q3` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`wan-ai/wan2.1-pro-i2v` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`wan-ai/wan2.2-i2v-a14b` _{values are provider-wide, not specific to this model}	—	`1280x720`, `720x1280`, `960x960`	—	—	—
`wan-ai/wan2.5-preview` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`wan-ai/wan2.6-flash-i2v` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`wan-ai/wan2.6-t2v`	—	`10801920`, `1088832`, `12481632`, `1280720`, `14401440`, `16321248`, `19201080`, `7201280`, `8321088`, `960960`	2–15s	—	—
`wan-ai/wan2.7-i2v`	`720P`, `1080P`	—	2–15s	—	—
`wan-ai/wan2.7-r2v`	`720P`, `1080P`	—	2–15s	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`wan-ai/wan2.7-t2v`	`720P`, `1080P`	—	1–10s	`16:9`, `1:1`, `3:4`, `4:3`, `9:16`	—
`xai/grok-imagine-1.5-video` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`xai/grok-imagine-video` _{values are provider-wide, not specific to this model}	`256p`, `360p`, `480p`, `540p`, `580p`, `720p`, `768P`, `1080p`, `true_1080p`, `1440p`, `2K`, `2160p`, `4k`, `1x`, `2x`, `4x`	—	1–30s	`16:9`, `1:1`, `21:9`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `9:21`, `adaptive`, `auto`	—
`xai/grok-imagine-video-1-5`	`720p`, `1080p`	—	1–15s	—	frames ×1, ref images ×7

_{135 models. A dash means the model does not take that parameter, or publishes no value for it.}

What the route dropped

A parameter the serving model does not implement is not an error. Mesh takes the request, generates the video without that parameter, and names it in unsupported_params on the response to your POST:

{
  "id": "t-xxxxxxxxxxxxxxxx",
  "status": "queued",
  "unsupported_params": ["bgm", "negative_prompt"],
  "dropped_parameters": [
    { "name": "bgm", "reason": "not_supported_by_offering", "offering": "byteplus/dreamina-seedance-2-0" },
    { "name": "negative_prompt", "reason": "not_supported_by_offering", "offering": "byteplus/dreamina-seedance-2-0" }
  ]
}

unsupported_params is a flat array of top-level field names, spelled as you sent them, sorted alphabetically. dropped_parameters carries the same drops in the shape chat and image responses use. offering is the model the request was graded against, which is the model that served it if a submit-time fallback moved it. class (advisory or output_semantic) appears when Mesh knows it. Read it before concluding a parameter had no effect: a video that ignored your negative prompt and a video whose negative prompt did nothing useful look identical, and this is what tells them apart. Three things about it will catch you out:

It is on the POST response only. Polling, the list endpoint and the webhook payload do not carry either field, and it is not stored, so if you throw the create response away you cannot get it back. Log it next to the task ID.

It is null, not [], when nothing was dropped. So is dropped_parameters. A truthiness check on .length throws. Guard for null. It names top-level parameters only. model and content are excluded — but a content item the model cannot take is never silently dropped either. It is refused with a 422 at submit, because a dropped asset changes what gets generated and you would be billed for it: a dropped tunable still gives you the video you asked for, tuned differently. Treat a non-empty unsupported_params as something to fix rather than something to live with: the request you meant to send and the request that ran are not the same one.

Getting the result

Two ways to collect a finished video: ask for it, or have it delivered. Polling is the source of truth. A callback is a shortcut that can arrive before your next poll, and on Kling and MiniMax it is skipped if a poll (yours or Mesh’s own background check) settles the task first. You can do both: usage logging is deduplicated, so you are never billed twice.

Approach	Best for
Webhook	Production apps and background pipelines — event-driven, no polling overhead
Polling	Scripts, testing, anywhere you cannot expose a public endpoint

Poll for the result

GET /v1/video/generations/{id} returns the task’s current state. While a task is still running, Mesh fetches the latest status live before answering; once it has finished, later calls are served straight from Mesh.

Python
curl

import time
import requests

TASK_ID = "t-xxxxxxxxxxxxxxxx"
headers = {"Authorization": "Bearer rsk_YOUR_KEY"}

while True:
    task = requests.get(
        f"https://api.meshapi.ai/v1/video/generations/{TASK_ID}",
        headers=headers,
    ).json()

    if task["status"] == "succeeded":
        print("Video:", task["content"]["video_url"])
        break
    if task["status"] in ("failed", "expired", "cancelled"):
        print("Did not finish:", task.get("error"))
        break

    print("Still", task["status"])
    time.sleep(5)

while true; do
  RESULT=$(curl -s "https://api.meshapi.ai/v1/video/generations/$TASK_ID" \
    -H "Authorization: Bearer rsk_YOUR_KEY")
  STATUS=$(echo "$RESULT" | jq -r '.status')
  echo "Still $STATUS"
  if [[ "$STATUS" != "queued" && "$STATUS" != "running" ]]; then
    echo "$RESULT" | jq
    break
  fi
  sleep 5
done

A five-second interval is a reasonable place to start. Branch on status, never on the HTTP code: a task that failed still returns 200. Polling a task that has not settled yet triggers a live upstream check, so it needs a key with the video:write scope. A video:read-only key gets 403 there, and can watch progress through the list endpoint instead. An unknown task ID, or one that belongs to another account, returns 404. If your key’s routing policy allows fallback, a submit the first provider rejects can be retried on another provider or model before the task is created. Polling and billing follow the route that accepted it.

You can poll with your own request id instead. Pin X-Mesh-Version: 2026-09 or newer, and the same endpoint also accepts the request_id Mesh returned when you created the task — useful when that id is already what you logged or stored:

curl "https://api.meshapi.ai/v1/video/generations/req_01ARZ3NDEKTSV4RRFFQ69G5FAV" \
  -H "Authorization: Bearer rsk_YOUR_KEY" \
  -H "X-Mesh-Version: 2026-09"

The task id is tried first, so nothing you already poll by changes. From 2026-09 the task body also carries a request_id field. Tasks created before 20 August 2026 have no request id recorded and stay reachable by task id only.

Status	Meaning
`queued`	Accepted, not started yet
`running`	Generating
`succeeded`	Done — `content.video_url` is your video
`failed`	Did not generate — read `error`
`expired`	Ran out of time before finishing
`cancelled`	Cancelled

A finished task looks like this:

{
  "id": "t-xxxxxxxxxxxxxxxx",
  "model": "byteplus/dreamina-seedance-2-0",
  "status": "succeeded",
  "content": {
    "video_url": "https://cdn.example.com/videos/generated.mp4",
    "last_frame_url": "https://cdn.example.com/videos/last-frame.jpg"
  },
  "usage": { "completion_tokens": 200, "total_tokens": 200 },
  "resolution": "1080p",
  "ratio": "16:9",
  "duration": 5,
  "frames": 150,
  "framespersecond": 30,
  "billed_resolution": "1080p",
  "billed_usd": 0.0015,
  "settled": true,
  "created_at": 1718000000,
  "updated_at": 1718000180
}

Field	Description
`id`	Task ID
`model`	The model that ran
`status`	Current status
`content.video_url`	Your video, once `succeeded`
`content.last_frame_url`	Still of the final frame, when you asked for `return_last_frame`
`error.code` / `error.message`	Why it failed, when it did
`request_id`	The `req_` id of the request that created the task (from `X-Mesh-Version: 2026-09`)
`usage.completion_tokens` / `usage.total_tokens`	Tokens billed, on token-billed models only. `null` otherwise
`billed_seconds` / `billed_resolution`	The length and resolution tier you were charged for, on models priced by duration or resolution
`billed_usd`	What the task cost, in USD. `null` until it settles
`settled`	`true` once billing for the task is recorded. Tells “not billed yet” apart from “billed nothing”
`duration`, `resolution`	What you requested
`seed`, `ratio`, `frames`, `framespersecond`, `generate_audio`	What the output is. Returned by BytePlus models, and only on a poll that fetched the status live; `null` otherwise
`created_at` / `updated_at`	Unix timestamps

Copy the video into your own storage when the task succeeds. Result URLs are there for you to fetch the file, not to serve it from your product.

Have the result delivered

Pass a callback_url on the create request and Mesh POSTs the task to it when it finishes. Only models served by BytePlus, Kling or MiniMax take a callback_url; on any other model the create call returns 422, and you poll instead. Kling and MiniMax tasks are delivered at most once, on a terminal status (succeeded, failed, expired). If a poll (yours or Mesh’s own background check) settles the task first, no callback is sent. BytePlus forwards every status update it sends, so expect running deliveries too and act on the terminal one. Treat the callback as a shortcut and polling as the source of truth.

{
  "model": "byteplus/dreamina-seedance-2-0",
  "content": [
    { "type": "text", "text": "A neon-lit street in the rain, slow dolly forward" }
  ],
  "duration": 5,
  "callback_url": "https://yourapp.example.com/webhooks/video"
}

The body is the same shape polling returns, with one difference: null fields are omitted rather than sent as null. Read a missing key as null, not as an error. To hear about every video task on the account without a per-request URL, subscribe to the video.completed and video.failed webhook events.

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/webhooks/video", methods=["POST"])
def video_webhook():
    task = request.json
    status = task["status"]

    if status == "succeeded":
        print(task["id"], "->", task["content"]["video_url"])
        # copy the file into your own storage here
    elif status == "failed":
        print(task["id"], "failed:", task.get("error", {}).get("message"))
    elif status == "expired":
        print(task["id"], "expired before finishing")

    return jsonify({"ok": True}), 200

Return a 2xx quickly, and do the heavy work afterwards. The callback is fire-and-forget with a 10-second timeout and no retry — a slow or failing endpoint means you miss that event for good. Poll as a backstop if missing one would matter.

List your recent tasks

GET /v1/video/generations returns your tasks, newest first. It is served from Mesh without checking upstream, so an in-progress task can show a stale status — call the single-task endpoint for a live one.

curl "https://api.meshapi.ai/v1/video/generations?status=succeeded&limit=10" \
  -H "Authorization: Bearer rsk_YOUR_KEY"

Parameter	Description
`status`	Filter by status. Repeatable, and multiple values are OR-ed: `?status=running&status=succeeded`.
`model`	Filter by model ID. Repeatable, OR-ed the same way.
`created_after` / `created_before`	ISO 8601 timestamps.
`limit`	Page size, 1–200 (default 50).
`offset`	Pagination offset (default 0).

{
  "object": "list",
  "data": [
    {
      "id": "t-xxxxxxxxxxxxxxxx",
      "model": "byteplus/dreamina-seedance-2-0",
      "status": "succeeded",
      "created_at": 1718000000,
      "updated_at": 1718000180,
      "content": { "video_url": "https://cdn.example.com/videos/generated.mp4" }
    }
  ],
  "has_more": false,
  "total": 1,
  "limit": 50,
  "offset": 0
}

What a video costs

How a video is billed depends on the model’s pricing.pricing_unit on GET /v1/models:

Pricing unit	How the charge is worked out
`per_1m_tokens`	`usage.completion_tokens` on the finished task at the model’s video rate: BytePlus Seedance and `google/gemini-omni-flash-preview`
`per_second`	Output seconds × the rate for the resolution tier, e.g. Kling, DeepInfra, OpenAI, AtlasCloud, most Runware and Veo models
`per_video`	A flat price per clip, on some models tiered by resolution

Where a model prices them separately, audio (generate_audio: true) and video input change the rate, not always upward. On Seedance 2.x, generating from a video input is billed at a lower rate per token than video alone. Venice models bill the price Venice quotes for the shape you asked for. billed_usd on the finished task is what you were charged, and billed_resolution the tier it was charged at. Per-model rates are on the Pricing page, and Models & Pricing carries the live numbers.

When something is refused

A task that failed after it was accepted

The most common surprise here: a video task can be accepted and fail later. The GET returns HTTP 200 with status: "failed" and an error object — the failure is in the body, not the status code.

{
  "id": "t-xxxxxxxxxxxxxxxx",
  "status": "failed",
  "error": {
    "code": "content_policy_violation",
    "message": "The request could not be processed due to content policy."
  }
}

So always branch on status, and log error.code. Mesh’s own codes are:

`error.code`	Meaning
`content_policy_violation`	The provider refused the content. Mesh folds every provider’s spelling of a content refusal into this one code
`video_generation_failed`	The provider reported a failure without giving a reason
`task_abandoned`	A poll-only provider never reported a terminal status within an hour. Closed and not charged
`provider_resource_not_found`	The provider no longer has the task, usually purged after its retention window
`upstream_error`	The provider reported a failure. Kling, Runware, DeepInfra, AtlasCloud, Novita and AI Studio Veo tasks
`provider_video_failed`	The provider reported a failure. MiniMax, SiliconFlow and fal tasks
`provider_video_no_file`	MiniMax reported success but returned no file to download. Not charged
`video_rehost_failed`	The video was generated but Mesh could not store it for delivery. Gemini and AI Studio tasks. Not charged

Any other code is the provider’s own, passed through as it sent it; message carries the provider’s explanation.

Where to look first

What you saw	Usually means
Accepted, then `failed` minutes later	Two input scenarios in one request, or parameters that contradict the reference job the model inferred
A parameter that did nothing	The model does not implement it — check `unsupported_params` and the capability flags
A reference image that seems ignored	Screening declined it, or a subject group whose main view was not first
`422` saying a reference is still being prepared	Registration is still in flight — retry the same request
A plain HTML `413` with no error body	The request body exceeded 32 MiB at the edge
`400` on a prompt-only request	The model needs input media — an image-to-video or upscaling model
`400` `model_capability_not_supported` naming a resolution	The model cannot render that resolution. Some Runware models refuse tiers outside their own list
`422` naming `callback_url`	The model’s provider has no webhooks. Poll instead

HTTP status reference

Status	Meaning
`200`	Task created, or retrieved
`400`	The model needs media this request did not carry, or cannot render the requested resolution
`401`	Missing or invalid API key
`402`	Insufficient balance, or a spend cap reached
`403`	Polling an unsettled task with a key that lacks the `video:write` scope
`404`	No task with that ID on your account
`422`	Not a video model, or a `role`, `subject` or parameter value the endpoint rejects
`429`	Rate limit exceeded
`502`	Upstream error while generating
`503`	Video generation temporarily unavailable

429, 502 and 503 are usually transient — retry with backoff. For anything else, Video generation troubleshooting walks through the specific symptoms, and the error reference covers codes shared across the API.

​Your first video

​Giving the model something to work from

​Pick one input scenario, not two

​Start from an image

​Open and close on exact frames

​Work from reference images

​Name your subjects

​Keeping a character consistent

​Work from a clip

​Work from a soundtrack

​Upscale an existing video

​Finer roles, documents and keyframes

​What you can send

​Older spellings

​Shaping the output

​The basics

​Finer control

​Say which reference job you mean

​Preview first, then render

​Finding out what a model accepts

​Check the flags before you send

​What each model accepts

​What the route dropped

​Getting the result

​Poll for the result

​Have the result delivered

​List your recent tasks

​What a video costs

​When something is refused

​A task that failed after it was accepted

​Where to look first

​HTTP status reference

Your first video

Giving the model something to work from

Pick one input scenario, not two

Start from an image

Open and close on exact frames

Work from reference images

Name your subjects

Keeping a character consistent

Work from a clip

Work from a soundtrack

Upscale an existing video

Finer roles, documents and keyframes

What you can send

Older spellings

Shaping the output

The basics

Finer control

Say which reference job you mean

Preview first, then render

Finding out what a model accepts

Check the flags before you send

What each model accepts

What the route dropped

Getting the result

Poll for the result

Have the result delivered

List your recent tasks

What a video costs

When something is refused

A task that failed after it was accepted

Where to look first

HTTP status reference