Seedream 5.0 API: Flash vs Pro, from $0.03 per Image
Picking a Seedream 5.0 tier for an API integration? The short version: use Flash for volume work, transparent PNG edits and splitting an image into layers, at a flat $0.03 per image and about 16 seconds for a 2K render; use Pro when an edit must stay inside a marked region or the image carries a lot of text, at $0.03 per image at 1K and $0.06 at 2K, and plan for about a minute per image. Neither tier renders 4K.
Disclosure up front: the numbers below come from apimodels.app, which is the API I work on. apimodels.app is a multi-model API gateway: one API key and one OpenAI-compatible endpoint for image, video, audio and language models. Both Seedream 5.0 tiers from ByteDance are on it, as doubao-seedream-5-0-flash and doubao-seedream-5-0-pro. Latency and failure figures are from our production traffic over the last 7 days (sample size not disclosed), rounded.
Flash or Pro: the short answer
Both tiers use the same endpoint and request fields, so switching is a one-string change to model. What differs:
- Speed. Flash returns a 2K image in about 16 seconds at the median; Pro takes about 54 seconds at 1K.
- Features. Layer decomposition is Flash only. Transparent-background editing works on both. Pro's documented strengths are region edits steered by marks on the reference image, and in-image text in 14+ languages.
- Price at 2K. Flash stays at $0.03; Pro is $0.06.
- Routing. Pro has a second upstream route with automatic failover; Flash has one.
Output is 1K or 2K, one image per call, no watermark. aspect_ratio accepts 1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 5:4, 4:5 and 21:9; without it, text-to-image gives a square and an edit follows the reference image's shape. Up to 10 reference images go in images.
What a request looks like
The native contract is asynchronous: the create call returns a task id, and you poll it or pass a callback_url for a webhook. Example below (syntax-checked and written against our docs, not run for this post):
import json, os, time, requests
API = "https://api.apimodels.app/v1/images/generations"
H = {"Authorization": f"Bearer {os.environ['APIMODELS_API_KEY']}"}
def run(payload, wait_s=600):
r = requests.post(API, headers=H, json=payload, timeout=60)
r.raise_for_status()
task_id = r.json()["data"]["taskId"]
deadline = time.time() + wait_s
while time.time() < deadline:
d = requests.get(API, headers=H, params={"task_id": task_id}, timeout=30).json()["data"]
if d["state"] == "completed":
return d
if d["state"] == "failed":
raise RuntimeError(f"{d.get('failCode')} retryable={d.get('retryable')}: {d.get('failMsg')}")
time.sleep(3)
raise TimeoutError(f"still running, fetch {task_id} later")
# Split a poster into a base image plus transparent layers (Flash only)
split = run({"model": "doubao-seedream-5-0-flash",
"image_url": "https://example.com/poster.png",
"layer_decomposition": True,
"prompt": "Separate only the headline and the product. "
"Write every layer name and description in English.",
"size": "2K"})
meta = split["resultJson"]
meta = json.loads(meta) if isinstance(meta, str) else meta # arrives as a JSON string
for layer in meta["layers"][1:]: # z_index 0 is the base
print(layer["z_index"], layer["name"], layer["bounding_box"]["absolute"], layer["url"])
For a plain render, call run() with model, prompt, size ("1K" or "2K") and an optional aspect_ratio. The poll loop gives up waiting, not the task: a task that outlives your deadline still finishes and can be fetched by id.
Transparent PNG edits
Send exactly one PNG that already has an alpha channel, set background to "transparent", and describe the change. You get back a PNG with the transparency kept. It cannot create transparency from a text prompt alone and cannot be combined with output_format: "jpeg"; both are rejected up front with an error that says why. On Flash the output size follows the input and the price is the usual $0.03, which makes Flash the natural tier for this job.
Layer decomposition (Flash only)
Add layer_decomposition: true and one PNG or JPEG, and Flash returns a base image plus up to 16 transparent PNG layers, each with a name, a description, a z_index and a bounding_box. Leave out the prompt to split every main element, or name the parts you want.
- Billing is per output image, base included, at $0.03 each: a base plus 11 layers is $0.36. The create call reserves the 17-image maximum ($0.51) and settles to the real count.
- Layer names default to Chinese. End the prompt with "Write every layer name and description in English."
- The base is not your original. It is the picture with the layers lifted off and the gaps filled in.
- Layer PNGs are larger than their boxes, about 2 to 4 times per side. Scale each to
bounding_box.absolutebefore compositing. - It is much slower than a plain render. Busy images can take several minutes and the server allows up to 8, so run it asynchronously.
Region edits on Pro
Pro has no mask field. You mark the region on the reference image itself (a box, an arrow, a hand-drawn outline) or give coordinates in the prompt, then say what changes there and what stays. It suits swapping a label or correcting a line of text on a poster. It is steered, not pixel-exact, so check the result.
How long it takes
End-to-end time from the create call to the finished image, successful requests only, including any queueing and automatic rerouting:
| Tier, size and mode | p50 (s) | p90 (s) |
|---|---|---|
| Flash 2K, text-to-image | 16 | 19 |
| Flash, all requests | 16 | 28 |
| Pro 1K, text-to-image | 54 | 89 |
| Pro 1K, with reference images | 85 | 115 |
| Pro 2K, with reference images | 93 | 258 |
Other combinations, including the transparent and layer modes, had too little traffic in this window to report.
- If a person is waiting, use Flash. Its 2K p90 is under 20 seconds.
- Reference images add about 30 seconds to Pro at 1K, at the median.
- Pro 2K edits have a long tail. One in ten takes more than four minutes, so create the task and poll or take the webhook rather than holding a request open.
How often it fails, and what to retry
Over the same 7 days, about 2% of Pro requests and fewer than 1% of Flash requests were refused by content moderation. About 2.5% of Pro requests and under 2% of Flash requests failed for other reasons, all of them timeouts or temporary network errors. Failed tasks are not billed; the task shows a charge of zero.
- Pro has two upstream routes. If the first returns an error or has not finished within 150 seconds, the task moves to the second without the caller doing anything. Requests that explicitly ask for PNG output stay on the first route.
- Flash has one route. Connection errors and fast 5xx or 429 responses are retried on it automatically, but there is no second route.
Every failure carries a standard failCode and a retryable flag. Retry UPSTREAM_BUSY, UPSTREAM_FAILED and TIMEOUT at most twice, a few seconds apart; do not retry CONTENT_MODERATION, INVALID_INPUT or INSUFFICIENT_BALANCE. GET /v1/records/{task_id} returns the final status and the exact amount charged, so reconciling a batch is a single loop.
Did you get the size you asked for?
Task results list the real width and height of each image in images, next to resultUrls. Since results started carrying these fields, every Pro image we checked matched the requested tier and aspect ratio: 1360x768 for 1K at 16:9, 1536x2720 for 2K at 9:16, 2048x2048 for a 2K square. Flash does not have enough measured results yet.
Prices, as of October 27, 2026
| Model id | 1K | 2K | Billed |
|---|---|---|---|
doubao-seedream-5-0-flash | $0.03 | $0.03 | per image; layer splits per output image |
doubao-seedream-5-0-pro | $0.03 | $0.06 | per image |
Beyond the price, the same key also serves GPT Image, Gemini, Kling and the rest of the catalogue, there is no separate ByteDance cloud account to open, and billing is pay-as-you-go from one balance. All parameters are in the Seedream API reference with the layer-split examples and the Seedream 5.0 Pro API reference.
A worked cost estimate
Say a launch needs 300 catalogue images, 40 label fixes on hero shots, and 25 posters split into layers, averaging a base plus 9 layers each:
Catalogue 300 x $0.03 (Flash 2K) = $9.00
Labels 40 x $0.06 (Pro 2K, region edit) = $2.40
Layers 25 x 10 outputs x $0.03 (Flash split) = $7.50
Total $18.90
If the label fixes can be 1K, that line drops to $1.20. Each split holds $0.51 of balance until it settles, so ten in parallel hold $5.10.
When not to use it
- You need 4K, or several images per call. Neither tier renders 4K, and each call returns one image.
- You need mask-based inpainting. Pro's region edits are steered by marks and the prompt, not a mask.
- You need layers on Pro, or a second route on Flash. Layers are Flash only, and Flash runs on one upstream route. If that matters, retry retryable Flash failures on Pro in your own code.
- Your edits must keep a real person's identity. On Pro, edits whose output still shows an identifiable real person are refused by content review.
- You need a direct contract with ByteDance, for compliance paperwork or committed spend. Use ByteDance's own platform.
If none of those apply, the quickest test is one Flash 1K request with your own prompt. Each task and its exact charge then show up under Records in the apimodels.app console.
Drafted with AI assistance; prices and numbers checked against our API docs and records on Oct 25, 2026.
评论
发表评论