Seedream 4.0: Pricing, Editing and API Code (2026)

Seedream 4.0 is ByteDance’s image model that handles text-to-image generation and instruction-based image editing in one architecture. ByteDance released it in September 2025 and published a technical report describing a multimodal system: a single model that accepts text, one or more reference images, or both, and returns new images. Search for it and you get a jumble of results: the official page, the research paper, Reddit threads comparing it with Google’s Nano Banana, and a long tail of look-alike “free generator” sites. This post sorts through all of that. It covers what the model does, what it costs, how to call it from code, and when another model is the better choice.

What is Seedream 4.0?

Here are two terms first, since they come up throughout. Text-to-image (often shortened to T2I) means you describe a scene in words and the model draws it. Image editing means you supply an existing image plus an instruction, such as “replace the sky with a sunset” or “put this logo on the mug”, and the model changes what you asked for while keeping the rest. For a long time these were separate products with separate quirks. Seedream 4.0 puts both into one model, so the same visual understanding drives generation and editing.

Under the hood it is a diffusion model. Diffusion models are trained to turn random noise into a coherent image step by step. ByteDance’s report describes a diffusion transformer with a lot of engineering aimed at speed and high resolutions. You don’t need those internals to use the model, but they explain why it can produce large images quickly.

Four things set the Seedream 4.0 AI image generator apart from earlier versions:

• Unified generation and editing. One model family covers both, so prompts behave the same way across them.
• Multi-image input. You can pass several reference images, for example a product, a background and a style reference, and ask for one composed result.
• High resolution. ByteDance announced output up to 4K. That is the main point in Reddit threads comparing it with models capped at about one megapixel.
• Multiple outputs per request. One request can return a set of related images, which suits variations, storyboards or a product shown from several angles.

On Unicorn API the model comes as two IDs: Seedream 4.0 Text to Image (bytedance-seedream-v4-text-to-image) and Seedream 4.0 Image to Image (Edit) (bytedance-seedream-v4-edit). Both are listed with a release date of 8 September 2025.

Seedream 4.0 text-to-image vs image editing

The two versions share most of their inputs. The one practical difference is that the edit version needs image_urls: a list of publicly reachable image URLs for the model to work from. If you forget it, you are effectively asking an editor to edit nothing.

	Text to Image	Image to Image (Edit)
Model ID	bytedance-seedream-v4-text-to-image	bytedance-seedream-v4-edit
Required input	prompt	prompt, image_urls
Optional input	seed, image_size, image_resolution, max_images, nsfw_checker	Same as text to image
Best for	New scenes, concept art, ad backgrounds, illustrations	Product placement, retouching, style changes, combining references
Price	5 credits per image	5 credits per image

What the inputs do:

• prompt: what to draw, or for the edit version, what to change. Write it as a plain instruction.
• image_urls (edit only): one or more source images. Use several when you want the model to combine them.
• seed: a number that fixes the random starting point. The same prompt with the same seed gives a closely matching result, which is how you reproduce an image or change one word and compare.
• image_size and image_resolution: control the shape and pixel size of the output. Check the API documentation for the values each accepts instead of guessing.
• max_images: caps how many images one request can return. Billing is per output image, so this field directly affects cost.
• nsfw_checker: toggles the content safety filter.

A useful rule: if you are starting from nothing, use text-to-image. If there is a real thing in the picture that has to stay recognisable, like your product, your logo or a specific person’s photo you have rights to, use edit and pass that image in.

How much does Seedream 4.0 cost?

On Unicorn API, both Seedream 4.0 models cost 5 credits per output image. Prices are rounded up to whole credits, and since 5 is already a whole number, there are no surprises. What you pay per credit depends on how you buy credits:

• Monthly plans give credits at $0.01 each, so one Seedream 4.0 image costs $0.05.
• Top-ups cost $0.015 per credit and never expire, so one image costs $0.075.

Here is what each plan buys if you spent it all on this one model:

Plan	Monthly price	Credits	Seedream 4.0 images
Starter	$25	2,500	500
Creator	$50	5,000	1,000
Studio	$100	10,000	2,000
Pro	$200	20,000	4,000

The cost is per output, not per request. If you raise max_images and the model returns four images, that request costs 20 credits. Most budgeting surprises with Seedream 4.0 come from this: someone turns on batch output for variations and forgets that each variation is billed.

When you need certainty before running anything, for example in an app that shows users a price, call POST /v1/models/price with the model and input you plan to send. It returns the exact credit cost of that request. Full plan details are on the pricing page.

How to use Seedream 4.0 through the API

Every media model on Unicorn API works the same way. Image generation takes longer than a normal web request, so you don’t wait on an open connection. Instead you create a job (a queued unit of work), get back its ID, and poll until it finishes. The flow:

1. Create an API key on the keys page and export it as UNICORN_API_KEY.
2. Send POST /v1/jobs with the model ID and an input object.
3. Poll GET /v1/jobs/{id} every few seconds until status is "succeeded".
4. Read the image URL from outputs[0].url and download it.

Quick test with curl

This is the smallest working Seedream 4.0 request: text in, image job out.

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bytedance-seedream-v4-text-to-image",
    "input": {
      "prompt": "A red fox resting in a snowy forest at dawn, soft light, highly detailed"
    }
  }'

# Use the id from the response to check progress:
curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

Worked example: generate a product shot, then edit it

Here is a realistic task. You need a hero image of a ceramic mug for a shop page, then a second version of the same mug in a lifestyle setting. The text-to-image model makes the first image. The edit model takes that image and places the mug on a café table without redesigning it. Total cost: two images at 5 credits each, so 10 credits, or $0.10 on a monthly plan.

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}


def run_job(model, input_, timeout_s=300):
    """Create a job, poll until it succeeds, and return the finished job."""
    r = requests.post(
        f"{API}/v1/jobs",
        headers=HEADERS,
        json={"model": model, "input": input_},
        timeout=30,
    )
    r.raise_for_status()
    job = r.json()

    deadline = time.time() + timeout_s
    while job["status"] != "succeeded":
        if job["status"] == "failed":
            raise RuntimeError(f"Job {job['id']} failed: {job}")
        if time.time() > deadline:
            raise TimeoutError(f"Job {job['id']} still {job['status']}")
        time.sleep(3)
        r = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS, timeout=30)
        r.raise_for_status()
        job = r.json()
    return job


# Step 1: generate the studio product shot from text
generated = run_job("bytedance-seedream-v4-text-to-image", {
    "prompt": (
        "Studio product photo of a matte sage-green ceramic coffee mug, "
        "white seamless background, soft diffused light, sharp focus, "
        "subtle shadow under the mug"
    ),
    "seed": 42,
})
product_url = generated["outputs"][0]["url"]
print("Product shot:", product_url)

# Step 2: edit the same mug into a lifestyle scene
edited = run_job("bytedance-seedream-v4-edit", {
    "prompt": (
        "Place this exact mug on a worn oak table in a sunny cafe, "
        "steam rising from fresh coffee, blurred window in the background. "
        "Keep the mug's shape, color and glaze unchanged."
    ),
    "image_urls": [product_url],
})
print("Lifestyle shot:", edited["outputs"][0]["url"])

Some details in this code are deliberate:

• The seed in step 1 means you can rerun the script and get a near-identical mug. Change the seed when you want a different one.
• The edit prompt says what to change and also what to keep. Editing models follow instructions closely, and spelling out the parts that must stay fixed cuts down on drift.
• The polling loop has a timeout and a failure check, so a stuck job doesn’t hang your script forever.

If you’d rather try prompts before writing code, the same models run in the browser in the image playground. If you work in Cursor or Claude Code, the agents setup lets your coding assistant call these models directly.

Seedream 4.0 vs Nano Banana, GPT Image and Seedream 5.0

“Nano banana seedream 4.0” is a common search because people want to know which one to use. The honest answer is that they are good at different things, and the cheapest way to choose is to run your actual prompt through each one. That is easy when they all sit behind the same key. Here is how they compare on Unicorn API:

Model	Credits per image	Reference images	Notable strengths
Seedream 4.0 (text or edit)	5	Edit version: list of image_urls	Generation and editing in one family, high-resolution output, multiple images per request
Nano Banana 2 Lite	4	Up to 10	Cheapest Gemini image model, fast 1K images and edits, seven aspect ratios
Nano Banana 2.1	4 (1K), 6 (2K), 9 (4K)	Via image_input	Choose output resolution per request, selectable output format
GPT Image 1.5	3 (low), 4 (medium), 22 (high)	Up to 4	Reliable prompt adherence, legible text, optional transparent background
Seedream 5.0 Flash Image to Image	3.24, rounded up to 4	Via image_urls	Newer Seedream generation for image-to-image work, 1K to 2K sizes

How to read the table:

• If cost per image is what matters most and 1K is enough (social posts, thumbnails, drafts), Nano Banana 2 Lite is the low-cost default. Its 10-reference limit also makes it strong for character or product consistency.
• If you need words inside the image (posters, packaging mockups, UI screenshots), GPT Image 1.5 is built for legible text. Its transparent background option suits stickers and product cutouts. Watch the quality setting: high is 22 credits per image.
• If you want resolution control on a Google model, Nano Banana 2.1 charges by resolution, and 4K costs 9 credits.
• If you like the Seedream look but mostly edit images, test Seedream 5.0 Flash. Note the rounding: 3.24 credits is billed as 4 per output.
• Seedream 4.0 makes sense when you want one model family for both creating and editing, need several related outputs from one request, or simply prefer its style on your prompts.

For more on Google’s models, see how to use Nano Banana. For a wider look at photorealistic options, the real AI image generator roundup compares more models. The full list is in the model catalog.

Is Seedream 4.0 open source or free?

“Seedream 4.0 open source” is a frequent search, and the answer is no. ByteDance published a detailed technical report, so the research is public, but it has not released the model weights. You can’t download Seedream 4.0, run it on your own GPU or fine-tune it locally. The only ways to use it are hosted ones: ByteDance’s own products, or an API provider that has access to the model.

“Free” is murkier. Search results are full of sites with the model name in their domain offering a free Seedream 4.0 image generator. Keep three things in mind about them:

• Many are not ByteDance. They are third-party wrappers. Some are fine and some are not, and a matching domain name proves nothing.
• Free tiers are usually small. Expect a few images per day, lower resolution, watermarks or a slow queue. Terms change often.
• Read the terms before uploading anything. For editing, you are handing over your own photos. Know where they go and whether they are kept.

The same applies to earlier versions such as Seedream 3.0: access depends on whichever app or site is hosting it, under that service’s rules. If you need dependable access you can script, a pay-per-image API is the practical route. At 5 credits an image, a few dozen test images cost about as much as a coffee, and you don’t depend on a free tier that might disappear.

Seedream 4.0 prompting tips and common mistakes

Prompts that work

• Describe in this order: subject, setting, light, style. “A matte green mug, on an oak table, morning window light, editorial product photography” beats a pile of adjectives.
• For edits, state what changes and what stays. “Change the background to a beach at sunset. Keep the person’s face, clothing and pose unchanged.” Without the second sentence, the model may change more than you wanted.
• When combining references, say which image is which. If you pass a product photo and a style reference, write “use the product from the first image and the color palette of the second image”.
• Fix the seed while you iterate. Change one thing in the prompt at a time with the same seed, so you can see what each change actually does.
• Ask for the use, not just the look. “Leave empty space on the right for headline text” gives you a layout you can use in an ad.

Mistakes people make

1. Calling the text-to-image model when they meant to edit. If your product has to stay recognisable, use bytedance-seedream-v4-edit and pass the image in image_urls. Describing the product in words never reproduces it exactly.
2. Passing private image URLs. The model fetches image_urls over the internet. Links that need a login, local file paths and expired signed URLs will fail. Host the image somewhere public, or use a signed URL that stays valid long enough for the job.
3. Forgetting per-output billing. Raising max_images multiplies the cost by the number of images returned. Check with POST /v1/models/price if you’re unsure.
4. Polling too aggressively. Checking every few seconds is plenty. Tight loops with no delay waste requests and don’t make the job finish sooner.
5. Treating output URLs as permanent storage. Download finished images into your own storage instead of linking to the output URL from production pages.
6. Hardcoding the API key. Keep it in an environment variable, as in the examples above, and never ship it in front-end code. Call the API from your server.
7. Picking a model from someone else’s samples. Results posted on Reddit or YouTube reflect someone else’s prompts. Run your own five or ten prompts through Seedream 4.0 and one or two alternatives, then decide.

If you’re starting today, a sensible path is to try a few prompts in the playground, then move the winning prompt into the Python script above. Use the Seedream 4.0 text-to-image model for new scenes and the edit model for anything built on an existing image, and set a seed so results are repeatable. Endpoint details and accepted values for every field are in the documentation.