Skip to main content
Use GET /v1/models to discover which models are available to the API and what they cost. Pass ?type=image, ?type=video, ?type=audio, ?type=3d, or ?type=video-depth to filter.

Reading the response

The model catalog is the source of truth for what’s available. Calling an image endpoint for a model that isn’t API-available returns 400 model_not_available — list the catalog to see current options.

Multiple images per request

Some image models return more than one image from a single call:
  • seedream-4.5 and seedream-5.0-lite support grouped generation. Set sequential_image_generation: "auto" and max_images (up to 4 on seedream-4.5, up to 14 on seedream-5.0-lite). The model returns a group of related images up to max_images and decides the exact count — it may return fewer (a plain prompt often yields one; a prompt that explicitly asks for a set yields several). Use max_images for this, not num_images.
  • seedream-5.0-pro does not support grouped generation — it has no sequential_image_generation parameter. Use num_images (1–4) for multiple takes; each is generated and billed independently. It prices by output size (1K = 55, 2K = 110 credits per image) and bills reference_images beyond the first at 5 credits each — see pricing & credits.
  • seedream-5.0-flash has no grouped generation either: use num_images (1–4). It costs a flat 25 credits per image at 1K or 2K, and its reference_images (up to 10) are free.
  • seedream-5.5 has no grouped generation: use num_images (1–4), each generated and billed independently. It prices by output size (1K = 26, 2K = 46 credits per image, 2K is the default) and bills 10 credits for every reference_images item (up to 10), per generated image — see pricing & credits. With aspect_ratio: "match_input_image" an edit keeps its input’s shape.
  • minimax-h3-image makes all of a request’s images (num_images 1–4) in one call; each image returned is billed. It prices by output size (2K = 34 credits per image, the default, or 4K = 100) and bills 12 credits for every reference_images item (up to 10), per generated image — see pricing & credits. aspect_ratio is auto (the default: an edit keeps its first reference’s shape) or one of 13 shapes from 9:21 to 21:9. No seed, negative prompt or transparent background.
  • flux-3-image takes num_images (1–4); each image is generated and billed independently at its size’s price. Its reference_images (up to 10) are free.
  • flux-3-image-klein (FLUX 3 Klein) takes the same request as flux-3-image without grounding: num_images (1–4), each generated and billed independently at its size’s price (768px = 11, 1K = 12, 1.5K = 15, 2K = 19, 4K = 48 credits per image), and up to 10 free reference_images. Most images up to 1.5K return in seconds.
  • nano-banana-2.1 takes num_images (1–4); each image is generated and billed independently at its size’s price, plus search grounding if you enabled it. Its reference_images (up to 9) are free.

Grounding

flux-3-image takes a grounding parameter (true by default). When it is on, the model researches the prompt with web and image search before rendering, which helps when the prompt depends on what something real looks like. It costs nothing extra. Set grounding: false for faster, self-contained generation.

Search grounding

nano-banana-2.1 takes two optional parameters that let the model look things up before it renders. Both are false by default and are priced per image when enabled: Because image search includes a web search, the two never add up: image_search: true costs 20 extra credits per image whether or not google_search is also set. GET /v1/models lists both amounts under option_pricing, and POST /v1/cost quotes the exact total for a request.
That request costs 45 + 10 = 55 credits. output_format (png or jpeg) sets the file you get back, at full resolution either way. Leave it out and the file comes as the model produced it, which is a PNG or a near-lossless JPEG; set it when your pipeline needs one or the other.

Transparent backgrounds

gpt-image-2.6-flare and gpt-image-2.6-sunburst make a cut-out from anything: with background: "transparent", a text-to-image request or an edit comes back with a transparent background, as a PNG (or a WebP with output_format: "webp"; a jpeg request is delivered as PNG, because JPEG has no transparency). auto, the default, lets the model decide, and opaque asks for a filled background.
seedream-5.5 makes a cut-out the same way: background: "transparent" from a text prompt alone or with reference_images, returned as a PNG with an alpha channel (a transparent request is always a PNG, whatever output_format asks). seedream-5.0-pro and seedream-5.0-flash take a background parameter (opaque, the default, or transparent). Transparent mode is for editing a cutout: send exactly one reference image, a PNG that already has transparent pixels (a product cutout, sticker or logo), and the result is a PNG that keeps the transparency. It can’t make a transparent image from text alone, and multi-reference requests must stay opaque — those requests are rejected with 400 before anything is charged.
Billing is per image returned: a result with 3 images costs 3 × credits_per_generation. When the job starts we reserve the maximum (max_images × credits_per_generation) and charge only for the images actually produced.

Video output format

Every video comes back as an MP4. The codec inside depends on the model and the resolution you ask for: The H.265 tiers are delivered exactly as the model produced them. We don’t re-encode them to H.264, because that would cost quality at the resolutions where you are paying for it. The job status says which codec you got:
video_codec is h264 or h265 on every finished video job (GET /v1/videos/{id}, /v1/video-upscales/{id}, /v1/depth-maps/{id}, /v1/motion-control/{id}, /v1/lip-sync/{id}). video_codec_note appears only with h265.
H.265 does not play everywhere. Safari, VLC, QuickTime and most phones play it. Chrome and Firefox need a hardware HEVC decoder, and without one they show a black frame with working audio. The file is not corrupted.If your player or pipeline needs H.264, check video_codec and transcode:
Or ask for a lower resolution: SeeDance 2.5 at 480p/720p and SeeDance 2.0 up to 1080p deliver H.264.

Video generation modes

Some video models accept different inputs for different modes.

SeeDance 2.5 (flagship)

SeeDance 2.5 (seedance-2.5) is ByteDance’s flagship multimodal model. One endpoint, three modes — there is no separate video-edit endpoint:
  • Text-to-video — prompt only (aspect_ratio applies here; other modes are adaptive).
  • Image-to-video — a start frame (image), optionally with an end frame (end_image).
  • Reference-to-video — any mix of up to 30 reference_images (free), up to 10 reference_videos (each 2–30s — a clip the prompt edits 4–30s — 30s combined), and up to 10 reference_audios (each 2–30s, 30s combined, free; audio-only input works). Editing or extending an existing clip = passing it as a reference_videos entry. Reference media can’t be combined with start/end frames.
Output is 480p, 720p or 1080p, any duration 4–30 seconds, priced per second (480p = 150, 720p = 330, 1080p = 750 credits). reference_videos additionally bill per second of input at half the output rate (480p = 80, 720p = 160, 1080p = 375 credits per input second) — use POST /v1/cost for an exact quote (it probes your clips).
1080p output is H.265 (HEVC), 10-bit. 480p and 720p are H.264. H.265 does not play in every browser — see video output format.

Draft mode: a 480p draft, then its 1080p final

Make a cheap 480p draft first, and pay for 1080p only once you like the result. The final is the same video rendered again at 1080p, with the same motion, framing and sound, only sharper.
  1. Send "draft": true and leave resolution out. A draft is priced like any 480p video.
  2. Poll GET /v1/videos/{id}. A finished draft carries draft_finalizable, draft_expires_at (7 days after it was made) and draft_final_credits, the final’s standard price.
  3. Send the draft’s id as from_draft_job_id, with no other parameters. The final reuses the draft’s prompt, inputs, length, aspect ratio, seed and audio setting.
A draft costs 150 credits per second (plus 80 per second of reference-video input). Its final costs 750 per second of the draft’s length (plus 375 per second of the draft’s reference-video input), so a 5-second draft costs 750 credits and its final 3,750. POST /v1/cost quotes both: send from_draft_job_id to price a final. Drafts made in the Video Workshop or over MCP can be finalized through the API, and the other way round. Like any 1080p SeeDance 2.5 output, a final is H.265.

SeeDance 2.5 Flash

SeeDance 2.5 Flash (seedance-2.5-flash) is ByteDance’s faster, lower-cost SeeDance 2.5. It takes the same three modes and the same request fields as SeeDance 2.5 above (editing or extending a clip is a reference_videos entry here too), with these differences:
  • 480p or 720p output (no 1080p), any duration 4–30 seconds. Both sizes are H.264.
  • Up to 10 reference_images (free), 5 reference_videos (each 2–30s — a clip the prompt edits 4–30s — 30s combined) and 5 reference_audios (each 2–30s, 30s combined, free; audio-only input works).
  • No draft mode: draft and from_draft_job_id are SeeDance 2.5 only.
Priced per second of output (480p = 93, 720p = 200 credits). reference_videos additionally bill per second of input (480p = 57, 720p = 123 credits per input second). A 5-second 720p video costs 1,000 credits, against 1,650 on SeeDance 2.5. POST /v1/cost gives an exact quote.

SeeDance 2.0

SeeDance 2.0 (seedance-2.0) supports all of these from one endpoint:
  • Text-to-video — prompt only.
  • Image-to-video — a start frame (image), optionally with an end frame (end_image) to interpolate between the two.
  • Reference-to-video — up to 9 reference_images, 3 reference_videos and 3 audio clips (audio plus reference_audios), each clip 2–15s and each kind 15s combined. Reference videos bill per second of input at half the output rate; audio needs a reference image or video next to it.
  • Video-to-video — supply a video to edit an existing clip. Video inputs are passed by URL (a public URL or one from POST /v1/uploads), not inlined as base64. You can also pass reference_images (up to 9), up to 2 more reference_videos (the video is “Video 1”; 15s combined) and up to 3 audio clips alongside the video to guide the edit.
Start/end frames (image/end_image) can’t be combined with reference_images or a video. But reference_images can accompany a video — that runs a reference-guided video-edit (up to 9 reference images either way). Pricing is per second, by resolution (see resolution_pricing): a 5-second 1080p clip costs 5 × 550. The 4k resolution is available for text/image/reference modes, not video-to-video. 4K output is H.265 (HEVC), 10-bit; 480p to 1080p are H.264 — see video output format. Reference audio (optional): attach up to 3 audio clips — an audio track and/or reference_audios (MP3/WAV, 2–15s each, 15s combined, by public URL or one from POST /v1/uploads) — to a request with reference_images, reference_videos or a video, and SeeDance 2.0 uses them in the generated video. Audio can’t be the only input, and it can’t be combined with start/end frames. Cheaper tiers: seedance-2.0-fast and seedance-2.0-mini support the same modes at lower per-second rates, in 480p and 720p (no 1080p/4k). Check each model’s resolution_pricing in GET /v1/models, or POST /v1/cost to price an exact request.

MiniMax H3

MiniMax H3 (minimax-h3) is a multimodal 2K model with a different reference surface:
  • Text-to-video — prompt only (aspect_ratio applies here; other modes are adaptive).
  • Image-to-video — a start frame (image), optionally with an end frame (end_image).
  • Reference-to-video — mix up to 5 reference_images, up to 3 reference_videos clips, and up to 3 reference_audios clips in one request. Clips are passed by URL (public or from POST /v1/uploads); each clip must be 2–15s, with at most 15s combined per media type.
Reference media can’t be combined with start/end frames, and H3 has no video-to-video edit mode. Output is 2K only, any integer duration from 4 to 15 seconds.
H3 is the first model that bills video input: reference_videos cost the model’s per-second rate on the input duration in addition to the output video. Reference images (first 5) and reference audio are free. POST /v1/cost fetches and measures the clips, so its estimate includes the input component.

MiniMax H3 Max

MiniMax H3 Max (minimax-h3-max) is a post-trained H3 tuned for stronger prompt adherence and aesthetics, with native audio. One endpoint covers every mode — the inputs decide which:
  • Text-to-video — prompt only; aspect_ratio defaults to 16:9. An optional audio URL pins a soundtrack (it replaces the generated audio, trimmed to the video length).
  • Image-to-video — image (first frame) and/or end_image (last frame). An end frame on its own is allowed. The output follows the frame image, so aspect_ratio is ignored. audio works here too.
  • Reference-to-video — up to 5 reference_images, 3 reference_videos (2–15s each, 15s combined) and 3 reference_audios (2–15s each, 15s combined). Address them in the prompt by order: “Image 1”, “Video 1”, “Audio 1”. aspect_ratio defaults to adaptive (the model picks); an explicit ratio is honored.
  • Extend — pass a video (1.6–60s, ≤50MB, aspect ratio between 2:5 and 5:2) and describe what happens next. length_seconds is the new footage appended; the output is the source followed by the continuation. aspect_ratio defaults to auto (keep the source framing); any other ratio crops.
Resolutions are 480p, 768p (default) and 1080p; 2k is available only when extending. Any integer duration from 5 to 15 seconds. Reference media can’t be combined with start/end frames, and video can’t be combined with any other media input.
Like H3, H3 Max bills video input: reference videos, and the source clip of an extension (first 15 seconds), cost 170 credits per input second on top of the output. Reference images beyond the first two add 50 credits each; reference audio and the soundtrack are free. POST /v1/cost measures the clips, so its quote is exact.

Wan 3.0

Wan 3.0 (wan-3.0-video) is Alibaba’s all-in-one model — one endpoint, three modes, no separate video-edit endpoint (the SeeDance 2.5 shape):
  • Text-to-video — prompt only. aspect_ratio is honored in every mode — an explicit ratio reframes the output even with a first frame or reference media, and the default adaptive lets the model pick a suitable ratio from the inputs and prompt.
  • Image-to-video — a first frame (image), optionally with a last frame (end_image) to interpolate between the two.
  • Reference-to-video — any mix of up to 10 reference_images (free), up to 5 reference_videos (each 2–15s, 15s combined), and up to 5 reference_audios (15s combined, free). Editing, replicating the style or camera move of, or extending an existing clip = passing it as a reference_videos entry. In the prompt you can address assets by their order in each type: “Image 1 hands Video 1 the guitar…”. Reference media can’t be combined with first/last frames.
Output is 480p, 720p or 1080p at 30fps, any duration 2–30 seconds, priced per second (480p = 60, 720p = 120, 1080p = 240 credits) — of output, and of reference-video input at the same rate.
Wan 3.0 bills video input like output: every reference_videos clip is measured and billed per second at the output rate for the chosen resolution, on top of the output. Reference images and audio are free. Example: a 5-second 720p edit guided by an 8.2s clip costs (5 + 9) × 120 = 1680 credits. With a video input, the input duration plus length_seconds must not exceed 30 seconds.
Need it faster? wan-3.0-video-prime is the high-speed tier: the identical API surface and modes with significantly faster end-to-end generation, at 85/170/340 credits per second (480p/720p/1080p), reference-video input included at the same rate.

Wan 2.7

Wan 2.7 (wan-2.7-video) serves three modes from one endpoint:
  • Text-to-video — prompt only.
  • Image-to-video — a start frame (image), optionally with an end frame (end_image) to interpolate between the two.
  • Video editing — supply a video and the model applies your prompt to that clip (restyle it, change the scene, alter a subject’s action or the camera move). The video is passed by URL (public or from POST /v1/uploads), not inlined as base64. Up to 4 reference_images may accompany it to guide the edit — for example, supplying the person or style to apply to the clip.
video can’t be combined with image/end_image. Output is 720p or 1080p; text- and image-to-video run 5, 10, or 15 seconds. Video editing behaves differently from the other two modes in two ways worth planning for: the input clip must be 2–15 seconds, and the output length is taken from that clip, so length_seconds is ignored.
Video editing bills the input clip at the full per-second rate, on top of the output — not the half rate the SeeDance families charge. Because the output length equals the input length, an edit costs roughly double what the same number of seconds costs in text-to-video: editing an 8.2s clip at 720p is 9 × 100 + 9 × 100 = 1800 credits. reference_images are free. POST /v1/cost fetches and measures the clip, so its estimate includes the input component — send the exact body you plan to generate with.

P-Video

P-Video (p-video) is a fast, low-cost model with three modes:
  • Text-to-video — prompt only.
  • Image-to-video — a start frame (image), optionally with an end frame (end_image) to interpolate between the two.
  • Audio-driven — supply an audio track (MP3/WAV/FLAC) by URL and the model generates video to match it.
Output is 720p or 1080p at 5 or 10 seconds.
Supplying audio makes the output length match the audio, and length_seconds is ignored. Because P-Video is billed per second, a 23-second track produces a 23-second charge no matter what length_seconds said. Send the exact body you plan to generate with to POST /v1/cost first.

P-Video 2 Pro

P-Video 2 Pro (p-video-2-pro) is Pruna AI’s video model built on MiniMax H3, with generated audio on every clip:
  • Text-to-video — prompt only, in any of seven aspect ratios.
  • Image-to-video — a first frame (image), a last frame (end_image), or both. A frame image sets the shape of the video, so aspect_ratio is ignored then.
Output is 480p or 768p, any whole number of seconds from 5 to 15, at 24 fps. mode picks how the video is rendered, and it sets the price together with resolution: cost is the cheapest and also the fastest (about 20 seconds for a 5-second clip), speed is the default, and quality is the most detailed and the slowest.
GET /v1/models lists the full price table for this model as mode_pricing (credits per second, by mode and then resolution); its resolution_pricing is the default (speed) row. POST /v1/cost quotes the exact mode, resolution and length_seconds you send.

FLUX 3 Video

FLUX 3 Video (flux-3-video) is Black Forest Labs’ video model, with sound generated alongside the picture (effects, ambience, and dialogue with lip sync: a line in quotes in the prompt is spoken). generate_audio: false makes a silent clip at the same price.
  • Text-to-video — prompt only, in any of eight aspect ratios from 21:9 to 9:21. The model renders text inside the scene (signs, titles) and can cut between several shots from one prompt.
  • Image-to-video — a first frame (image), optionally with a last frame (end_image): the video moves from one to the other. The frame sets the shape of the video, so aspect_ratio is ignored then.
  • Video extension — supply a video (MP4 or MOV, 1 second to 2 minutes) and the model continues it from its last frames for length_seconds of new footage (5 to 15). The result is one video: your clip followed by the new footage, at the resolution you pick.
Output is 720p, 1080p, 1440p or 4K at 24 fps, any whole number of seconds from 5 to 20. At 16:9 those are 1280x704, 1920x1088, 2560x1440 and 3840x2176 (BFL’s sizes are multiples of 32).
FLUX 3 Video is billed per second of output by resolution, and an extension at its own, higher rate for the new seconds only (the source clip is free). GET /v1/models lists both rows as mode_pricing (generate and extend, credits per second by resolution); the mode follows your inputs, so there is no mode parameter. POST /v1/cost quotes the exact body you send.

Kling 4.0

Kling 4.0 (kling-4.0) is Kuaishou’s video model, with sound generated alongside the picture: dialogue, music and sound effects come from what the prompt describes. One endpoint covers every mode, picked by the inputs you send:
  • Text-to-video — prompt only, in 16:9, 9:16, 1:1 or 21:9.
  • Keyframes — a first frame (image), optionally with a last frame (end_image). The frame sets the shape of the video, so aspect_ratio is ignored then.
  • Reference images — up to 10 reference_images of characters, products, places or styles to keep consistent. Frames and reference images combine: 10 images in all.
  • Reference videos — reference_videos to take motion, camera work or style from.
  • Video editing — supply a video and describe the change. The output keeps the clip’s length and aspect ratio, so length_seconds and aspect_ratio are ignored; reference_images and reference_videos may guide the edit.
Name inputs in the prompt by position: @image_1, @image_2, … count image, then end_image, then reference_images; @video_1, @video_2, … count video, then reference_videos. With a first frame and two reference images, the references are @image_2 and @image_3. Input videos (up to 5 and 30 seconds in all, the edited clip included) are MP4 or MOV, 3 to 30 seconds each, 700 to 4553 pixels on each side, with an aspect ratio between 2:5 and 5:2. Output is 720p or 1080p at 24 fps, any whole number of seconds from 3 to 30.
Kling 4.0 is billed per second of output by resolution. With any input video, every billed second costs less, and the billed seconds are the output plus the longer of the input videos and the output: editing a 5-second clip bills 10 seconds. See pricing for the rates; POST /v1/cost quotes the exact body you send, measuring any input video.

3D models

Two image-to-3D models turn one picture into a textured 3D model: a subject in, a GLB (plus more formats on one of them) out. Both are asynchronous — POST /v1/3d/{model} returns a job id immediately; poll GET /v1/3d/{id} every 15-30 seconds until status is succeeded (usually 2-5 minutes). Charged on success only. Both take an image (a public URL, a data URI, raw base64, or a URL from POST /v1/uploads) — one subject on a plain background works best. Options adjust the price: Tripo’s texture_quality (standard or detailed, +140 credits) and detailed_geometry (+270); Meshy’s rigging (+270, humanoid subjects only; the files gain the rigged model plus a walk and a run) and animation (+160, needs rigging). animation_move picks the move the animated character performs, free: an id from GET /v1/3d/moves, about 650 moves from dances to waves, cheers and walks (without it the move is 92, Double Combo Attack). Turning texture off instead of on lowers the price (Tripo 270, Meshy 1080). POST /v1/cost quotes the exact price for your chosen options before you generate.
3D model outputs are ephemeral: kept about 24 hours, then deleted. Like every API output, they’re never added to the BudgetPixel web library — download model_url (or each format in files) as soon as the job succeeds, and re-download before the window closes if you need to come back to it; there is no way to recover a file after it expires.

Retired models

Model providers occasionally withdraw a model. When that happens we take it out of GET /v1/models and its endpoint starts answering 410 Gone with the error code model_retired, naming the replacement:
POST /v1/cost returns the same error rather than quoting a price you could not spend. A 410 is permanent — retrying will not help; switch the model id in your request.
Retired so far: seedance-1.5-pro (2026-09-17, → seedance-2.0). Parameter schemas differ between models, so check the replacement’s fields in GET /v1/models before swapping the id — and its per-second rate, which is usually different too.

Requesting a model

Image, video, music, and sound-effect models each have their own endpoint and parameter schema — see the API Reference tab for each model’s accepted fields.