> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laozhang.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Seedream 5.5 API: transparent PNG at $0.035

> Call Seedream 5.5 (seedream-5-5-261028) on LaoZhang API: text-to-image, edits with up to 10 references, transparent PNGs, and splits into up to 99 layers.

Seedream 5.5 is the newest Seedream image model from BytePlus ModelArk, released on November 12, 2026. It returns transparent PNGs from a single `background` parameter and splits a finished image into up to 99 layers, reading the font and color of any text it finds.

| Item | Details |
| - | - |
| Model ID | `seedream-5-5-261028`; the BytePlus name `dola-seedream-5-5-261028` also works, at the same price |
| Endpoint | `POST https://api.laozhang.ai/v1/images/generations`, JSON body |
| Operations | Text-to-image, reference-image edits, transparent PNG, and layer decomposition, all on one endpoint |
| Price | Per output image, the same at every size, plus a fee per reference image; see [Billing](#billing) |
| Token | `default` group, billing mode Usage first (recommended) or Per-call; no BytePlus account needed |
| Size | `1K`, `1.5K`, `2K` (default), or exact pixels; no 3K or 4K |
| Output format | PNG by default, JPEG on request |
| Typical time | 12–20 seconds at 1K, 25–35 seconds at 2K |
| Launch notes | [Seedream 5.5 launch announcement](https://docs.laozhang.ai/en/announcements/seedream-5-5-2026-11.md) |

![A bookstore window at night with a cat asleep on a stack of books and a hand-lettered OPEN LATE sign, generated by Seedream 5.5](https://mintcdn.com/laozhangai-edd05f2c/HEoMLhnyMjdf-Yvq/images/samples/seedream-5-5-en-generate.jpg?fit=max\&auto=format\&n=HEoMLhnyMjdf-Yvq\&q=85\&s=6cfd5e49315c9bf7a0a0e55119f13b35)

Output of the Generate an image example: size 2K, watermark false. Returned at 2496×1664, resized for this page

![A white ceramic mug with small blue flowers on a transparent background, generated by Seedream 5.5](https://mintcdn.com/laozhangai-edd05f2c/HEoMLhnyMjdf-Yvq/images/samples/seedream-5-5-en-transparent.png?fit=max\&auto=format\&n=HEoMLhnyMjdf-Yvq\&q=85\&s=3f17d97dce5cc25f1d5710ed96d371f9)

Output of the transparent PNG example: background transparent, output\_format png, size 1K. Returned as a 1024×1024 RGBA PNG

## Seedream 5.5 vs 5.0

| | Seedream 5.5 | Seedream 5.0 Flash / 5.0 Pro |
| - | - | - |
| Transparent output | `background` on generate and edit requests | Only through layer decomposition |
| Layer decomposition | Background + up to 99 layers, a cap on the count, text style recognition | Background + up to 16 layers |
| Price per image | \$0.035 | Flash \$0.018, Pro \$0.12 |
| Reference images | \$0.008 each | Flash free; Pro \$0.003 each after the first |
| Default output format | PNG | JPEG |

* **Choose 5.5** for transparent product assets, fine-grained layers, and posters whose text you want to edit later.
* **Choose 5.0 Flash** for low-cost bulk generation.
* **Choose 5.0, 4.5, or 4.0** for 3K or 4K output, or for sequential generation (several related images per request). The [Seedream API guide](https://docs.laozhang.ai/en/api-capabilities/seedream-image.md) covers all of them.

## Before you start

**1. Create a token**

[Register](https://api.laozhang.ai/register), then open [Token management](https://api.laozhang.ai/token) and create a token in the `default` group. Set **Billing mode** to **Usage first** (recommended) or **Per-call**.

The `sk-` key you get calls Seedream 5.5 directly. You don't need a BytePlus or Volcengine account.

**2. Set up your environment**

Export the key and install `requests` for the API calls and Pillow for checking transparency:

```bash theme={null}
export LAOZHANG_API_KEY="YOUR_LAOZHANG_API_KEY"
python3 -m pip install requests pillow
```

**3. Add a save script**

Image URLs in the response are temporary (BytePlus says they last 24 hours), so save each image as soon as it arrives. Save this script as `save_images.py`. It handles both `url` and `b64_json` responses and names each file after the returned `output_format`:

```python save_images.py theme={null}
import base64
import json
import sys
from pathlib import Path

import requests

response_file, stem = sys.argv[1], sys.argv[2]
response = json.loads(Path(response_file).read_text())
if not response.get("data"):
    sys.exit(f"No image in {response_file}: {response}")

for number, item in enumerate(response["data"], start=1):
    if item.get("b64_json"):
        image = base64.b64decode(item["b64_json"].split(",", 1)[-1])
    else:
        download = requests.get(item["url"], timeout=120)
        download.raise_for_status()
        image = download.content
    # output_format is "png" (the default) or "jpeg".
    extension = "jpg" if item.get("output_format") == "jpeg" else "png"
    path = Path(f"{stem}-{number}.{extension}")
    path.write_bytes(image)
    print(f"Saved {path}")
```

For a general script shared by all image models, see [Save images from a response](https://docs.laozhang.ai/en/api-reference/images.md#save-images-from-a-response).

## Generate an image

Send only `prompt` to generate an image. This request produced the bookstore sample above:

```bash theme={null}
curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-5-261028",
    "prompt": "A cozy bookstore window at night with warm light, a cat sleeping on a stack of books, and a hand-lettered sign that reads \"OPEN LATE\"",
    "size": "2K",
    "response_format": "url",
    "watermark": false
  }' \
  -o seedream-5-5-generate.json

python3 save_images.py seedream-5-5-generate.json bookstore
```

The script prints `Saved bookstore-1.png`. A successful response looks like this:

```json theme={null}
{
  "model": "dola-seedream-5-5-261028",
  "created": 1794532892,
  "data": [
    {
      "url": "https://example.com/seedream-5-5.png",
      "size": "2496x1664",
      "output_format": "png",
      "background": "opaque"
    }
  ],
  "usage": {
    "input_images": 0,
    "generated_images": 1
  }
}
```

With a preset such as `2K`, the model picks the aspect ratio from the prompt. To fix the ratio, pass exact pixels instead, such as `2048x2048` or `2848x1600`, with the letter `x` between width and height.

### Generate with Python

This version saves the file with the extension that matches the returned `output_format`:

```python theme={null}
import base64
import os
from pathlib import Path

import requests

response = requests.post(
    "https://api.laozhang.ai/v1/images/generations",
    headers={"Authorization": f"Bearer {os.environ['LAOZHANG_API_KEY']}"},
    json={
        "model": "seedream-5-5-261028",
        "prompt": (
            "A cozy bookstore window at night with warm light, a cat sleeping "
            'on a stack of books, and a hand-lettered sign that reads "OPEN LATE"'
        ),
        "size": "2K",
        "response_format": "url",
        "watermark": False,
    },
    timeout=180,
)
response.raise_for_status()
item = response.json()["data"][0]

if item.get("b64_json"):
    image = base64.b64decode(item["b64_json"].split(",", 1)[-1])
else:
    download = requests.get(item["url"], timeout=120)
    download.raise_for_status()
    image = download.content

extension = "jpg" if item.get("output_format") == "jpeg" else "png"
output = Path(f"bookstore.{extension}")
output.write_bytes(image)
print(f"Saved {output} ({item['size']})")
```

## Create a transparent PNG

Set `background` to `transparent` and `output_format` to `png`. This request produced the mug sample above:

```bash theme={null}
curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-5-261028",
    "prompt": "A ceramic coffee mug with small blue flowers, product shot",
    "background": "transparent",
    "output_format": "png",
    "size": "1K",
    "response_format": "url",
    "watermark": false
  }' \
  -o seedream-5-5-transparent.json

python3 save_images.py seedream-5-5-transparent.json mug
python3 -c "from PIL import Image; print(Image.open('mug-1.png').mode)"
```

The last command prints `RGBA`, and the response item reports `"background": "transparent"`. `background` takes three values:

* `auto` (default): the model decides from the prompt and `output_format`. JPEG output never has an alpha channel.
* `transparent`: returns an RGBA image with a transparent background.
* `opaque`: returns an RGB image with a solid background.

`background` also works on edit requests that include `image`. Don't combine it with `layer_decomposition`: that request returns an error.

## Edit with reference images

Add `image` to edit an image or combine several. Pass one reference as a string, or up to 10 as an array.

* Each item is a public URL or a data URL such as `data:image/png;base64,...`, with the format name in lowercase.
* References are numbered in array order, so the prompt can say image 1, image 2, and so on.
* Each reference image costs \$0.008, so this two-image edit costs \$0.051 in total.
* Size and format limits per image are the same as for other Seedream versions: see [local images and their limits](https://docs.laozhang.ai/en/api-capabilities/seedream-image.md#how-do-i-send-a-local-image-and-what-are-the-limits).

This example sends two local files as data URLs. Replace `mug.png` and `table.jpg` with your own files:

```bash theme={null}
IMG1=$(base64 < mug.png | tr -d '\n')
IMG2=$(base64 < table.jpg | tr -d '\n')

curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @- \
  -o seedream-5-5-edit.json <<EOF
{
  "model": "seedream-5-5-261028",
  "prompt": "Place the mug from image 1 on the wooden table in image 2, in soft morning light. Keep the mug's shape, pattern, and colors.",
  "image": [
    "data:image/png;base64,$IMG1",
    "data:image/jpeg;base64,$IMG2"
  ],
  "size": "2K",
  "response_format": "url",
  "watermark": false
}
EOF

python3 save_images.py seedream-5-5-edit.json mug-on-table
```

### Edit with Python

```python theme={null}
import base64
import mimetypes
import os
from pathlib import Path

import requests


def to_data_url(path):
    """Convert a local image file to a data URL."""
    mime_type = mimetypes.guess_type(path)[0] or "image/png"
    encoded = base64.b64encode(Path(path).read_bytes()).decode("ascii")
    return f"data:{mime_type};base64,{encoded}"


response = requests.post(
    "https://api.laozhang.ai/v1/images/generations",
    headers={"Authorization": f"Bearer {os.environ['LAOZHANG_API_KEY']}"},
    json={
        "model": "seedream-5-5-261028",
        "prompt": (
            "Place the mug from image 1 on the wooden table in image 2, in soft "
            "morning light. Keep the mug's shape, pattern, and colors."
        ),
        "image": [to_data_url("mug.png"), to_data_url("table.jpg")],
        "size": "2K",
        "response_format": "url",
        "watermark": False,
    },
    timeout=180,
)
response.raise_for_status()
item = response.json()["data"][0]

download = requests.get(item["url"], timeout=120)
download.raise_for_status()
extension = "jpg" if item.get("output_format") == "jpeg" else "png"
Path(f"mug-on-table.{extension}").write_bytes(download.content)
print(f"Saved mug-on-table.{extension}")
```

## Split an image into layers

Layer decomposition turns one finished image into a background plus transparent PNG layers, one element per layer. Use it to move elements, swap the background, or rebuild a poster in a design tool.

A layer request needs:

* `"layer_decomposition": true`.
* Exactly one image in `image`: PNG or JPEG, at least 512×512 pixels in total, up to 30 MB.
* No `background` field.

Two options go in `layer_decomposition_options`:

* `max_images`: the most images to return, counting the background. Accepts 2–100 and defaults to 30. Set it to cap the cost.
* `text_recognition`: set `true` to get the text, font, and color of ordinary text layers.

```bash theme={null}
curl --fail-with-body --max-time 360 "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-5-261028",
    "image": "https://example.com/your-poster.jpg",
    "layer_decomposition": true,
    "layer_decomposition_options": {
      "max_images": 6,
      "text_recognition": true
    },
    "size": "1K",
    "response_format": "url",
    "watermark": false
  }' \
  -o seedream-5-5-layers.json

python3 save_images.py seedream-5-5-layers.json poster-layer
```

Replace the `image` URL with a publicly downloadable image of your own, or pass a data URL. With `max_images` set to 6, this request returns at most 6 images and costs at most \$0.218. At `1K` it usually takes 20–30 seconds; `2K` takes longer, so keep the client timeout at 300 seconds or more.

### Read the text recognition result

The first item in `data[]` is the opaque background, with `z_index` 0. Each later item is one transparent layer. With `text_recognition` on, a text layer looks like this (trimmed, from a poster):

```json theme={null}
{
  "size": "1616x649",
  "output_format": "png",
  "z_index": 2,
  "bounding_box": {"absolute": [0, 0, 836, 336], "normalized": [0, 0, 1000, 268]},
  "name": "Bold uppercase text \"SUMMER\"",
  "background": "transparent",
  "text_recognition": {
    "text": "SUMMER",
    "lines": [{"runs": [{"text": "SUMMER", "style": {"similar_font_family": "TikTok Sans", "foreground_color": "#FFFFFF", "bold": true, "italic": false}}]}]
  }
}
```

`text_recognition.text` holds the full text. `lines` splits it into lines, and each line into runs that share one style:

| Style field | Meaning |
| - | - |
| `similar_font_family` | The closest matching font family |
| `foreground_color` | Text color as a hex value |
| `bold`, `italic`, `underline`, `strikethrough` | Text decoration, `true` or `false` |
| `shadow`, `translucent` | Whether the text has a shadow or is semi-transparent |

Artistic lettering and handwriting don't get a `text_recognition` object.

### Recompose the layers

Each layer also carries `bounding_box.absolute`, its position on the background in pixels, plus an English `name` and a `description`. A layer PNG isn't necessarily the size of its box: the example above is a 1616×649 file that belongs in an 836×336 box. Scale each layer into its `absolute` box when you put the image back together.

[Read the layer response](https://docs.laozhang.ai/en/api-capabilities/seedream-image.md#read-the-layer-response) on the Seedream page explains every layer field, and [Save the layers and recompose the image](https://docs.laozhang.ai/en/api-capabilities/seedream-image.md#save-the-layers-and-recompose-the-image) has a Pillow script that reads the same fields.

## Parameters

| Parameter | Type | Required | Description |
| - | - | - | - |
| `model` | string | Yes | `seedream-5-5-261028` or `dola-seedream-5-5-261028` |
| `prompt` | string | For generate and edit | Image description or editing instruction; refer to references as image 1, image 2, and so on |
| `image` | string or array | For edits and layers | Up to 10 public URLs or data URLs; exactly one for layer decomposition |
| `size` | string | No | `1K`, `1.5K`, `2K` (default), or `WIDTHxHEIGHT`. Exact pixels must total 921,600 to 4,624,220, with an aspect ratio from 1/16 to 16 |
| `output_format` | string | No | `png` (default) or `jpeg` |
| `background` | string | No | `auto` (default), `transparent`, or `opaque`; not allowed with layer decomposition |
| `response_format` | string | No | `url` (default) or `b64_json` |
| `watermark` | boolean | No | Defaults to `true`, which adds an "AI generated" mark; send `false` to omit it |
| `layer_decomposition` | boolean | No | `true` splits one image into a background and transparent layers |
| `layer_decomposition_options` | object | No | `max_images` (2–100, default 30) and `text_recognition` (boolean) |
| `optimize_prompt_options` | object | No | `mode` accepts only `standard` |

Seedream 5.5 doesn't support sequential generation, streaming, or web search. Leave `sequential_image_generation`, `stream`, and web search options out of the request.

## Billing

**Each output image costs \$0.035 at 1K, 1.5K, or 2K, and each reference image adds \$0.008, including the first.**

| Request | Images returned | Cost |
| - | -: | -: |
| Text-to-image or transparent PNG | 1 | \$0.035 |
| Edit with 1 reference image | 1 | \$0.043 |
| Edit with 2 reference images | 1 | \$0.051 |
| Edit with 10 reference images | 1 | \$0.115 |
| Layer decomposition of 1 image | 6 (background + 5 layers) | \$0.218 |

* Non-200 responses, such as parameter errors and moderation blocks, aren't charged.
* A client timeout doesn't cancel the request. If the server finishes, the images are charged, so check [call logs](https://docs.laozhang.ai/en/faq/call-logs.md) before you resend.
* Call logs are the record of what each request actually cost.

> [!WARNING]
>
> **Layer decomposition charges \$0.035 for every returned image, including the background.**
>
> * Without `max_images`, a request can return up to 30 images and cost up to \$1.058.
> * Set `layer_decomposition_options.max_images` to cap the count. A cap of 6 keeps the cost at \$0.218 or less.
> * Set the client timeout to at least 300 seconds. If your client disconnects first, the request still finishes and is charged.

## Frequently asked questions

### What is the Seedream 5.5 model ID?

`seedream-5-5-261028`. The BytePlus name `dola-seedream-5-5-261028` also works at the same price, and the `model` field in the response shows `dola-seedream-5-5-261028` either way.

### How much does the Seedream 5.5 API cost per image?

\$0.035 per output image, whether you ask for 1K, 1.5K, or 2K. Each reference image adds \$0.008, and layer decomposition is billed for every returned image. The [Billing](#billing) table lists common requests.

### Does Seedream 5.5 support fast mode?

No. `optimize_prompt_options.mode` accepts only `standard`. Sending `fast` returns HTTP 400 with a message containing `must be standard for Seedream 5.5`, and the request isn't charged.

In the Seedream family, only 5.0 Pro and 4.0 accept fast mode.

### Can Seedream 5.5 generate 4K images?

No. The largest output is the `2K` preset or exact pixels up to 4,624,220 in total, such as `2048x2048` or `2848x1600`. There is no 3K or 4K preset. For 3K use Seedream 5.0, and for 4K use 4.5 or 4.0; see [which Seedream version to use](https://docs.laozhang.ai/en/api-capabilities/seedream-image.md#which-seedream-version-should-i-use).

### Can one Seedream 5.5 request return several images?

Only through layer decomposition, which returns a background plus layers in one response. Seedream 5.5 doesn't support sequential generation, so send one request for each image you need. To get several related images from one request, use Seedream 5.0's [sequential generation](https://docs.laozhang.ai/en/api-capabilities/seedream-image.md#how-does-sequential-generation-work-and-how-is-it-billed).

### Do I need a BytePlus account to use Seedream 5.5?

No. A LaoZhang API token in the `default` group with the Usage first or Per-call billing mode is enough. You don't need a BytePlus or Volcengine account or key.

## Related documentation

* [Seedream 5.5 launch announcement](https://docs.laozhang.ai/en/announcements/seedream-5-5-2026-11.md): what's new and how it compares with 5.0
* [Seedream API guide](https://docs.laozhang.ai/en/api-capabilities/seedream-image.md): Seedream 5.0 Flash, 5.0 Pro, 5.0, 4.5, and 4.0, plus layer fields and the recompose script
* [Choose an image generation API](https://docs.laozhang.ai/en/api-capabilities/image-generation-guide.md): compare Seedream with other image models
* [Images API reference](https://docs.laozhang.ai/en/api-reference/images.md): shared request and response format
* [Model and pricing catalog](https://docs.laozhang.ai/en/models.md): current prices and groups
* [Call logs](https://docs.laozhang.ai/en/faq/call-logs.md): check the model and charge for each request

### Sources

* [BytePlus ModelArk image generation API](https://docs.byteplus.com/en/docs/ModelArk/1541523) (checked November 13, 2026): request parameters, `size` ranges, `background`, layer options, and URL lifetime
* [BytePlus ModelArk model list](https://docs.byteplus.com/en/docs/modelark/model-list): Seedream 5.5 model name and release


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.