> ## Documentation Index > Fetch the complete documentation index at: https://docs.apiyi.com/llms.txt > Use this file to discover all available pages before exploring further. # Seedream 5.5 Is Live: 100-Round Editing, Native Transparency > ByteDance's Seedream 5.5 (seedream-5-5-261028) is live on APIYI: up to 100 rounds of multi-turn editing, native RGBA PNG output, layer decomposition and text OCR. Output starts at $0.020 per image, with 2K and reference images billed separately. ## Key Takeaways * **New model, live now**: `seedream-5-5-261028` through the official BytePlus channel, available in the `Default` and `SVIP` groups on the same `/v1/images/generations` endpoint as the rest of the Seedream family * **Multi-turn editing is the headline**: ByteDance says unedited regions are preserved at the pixel level, so the same image can go through **100 rounds** without drifting, blurring, or picking up color casts * **Native RGBA output**: text-to-image and image-to-image both return PNGs with an alpha channel, including partial transparency, with no background removal needed * **Up to 100 layer-decomposition images**: one base plus as many as 99 independent layers; regular text layers also return OCR text, per-line positions and approximate styling * **Two-part billing**: **\$0.008 per reference image**, **\$0.020 per 1K / 1.5K output**, **\$0.035 per 2K or custom-size output**; failed requests are not billed ## Background Seedream is ByteDance's image-generation family on BytePlus ModelArk. APIYI already served 5.0 Pro, 5.0, 5.0 Flash, 4.5 and 4.0, covering everything from maximum fidelity to high-volume low-cost output. The ByteDance Seed team released Seedream 5.5 on **9 November 2026**, and APIYI brought it online on **13 November**. This generation does not chase higher resolution. It targets the three pain points that keep image models out of professional production: stability across successive edits, usable transparent assets, and realism with small text. The old problem with multi-turn editing was compounding error. Each edit changed one area, but background, skin tone and material drifted, so by round fifteen the image no longer resembled the original. Seedream 5.5 is trained specifically on preserving unedited regions. In the official demo, one portrait goes through 100 successive edits — clothing, accessories and desktop objects change repeatedly, while small items such as rings and eyeglass frames are still edited precisely, with consistent occlusion and lighting. The other change is transparency. Getting an alpha-channel PNG used to require layer decomposition or manual cutout. Seedream 5.5 generates transparent or semi-transparent backgrounds directly, so generated elements can enter a design pipeline as standalone assets. ## Detailed Analysis ### Three core upgrades > [card] Multi-turn editing, pixel-level preservation > > ByteDance says unedited regions are kept at the pixel level, reducing color shifts, detail loss and image degradation across edits. The same piece supports up to **100 rounds** of continuous editing. > [card] Native RGBA assets > > Text-to-image and image-to-image both return images with an alpha channel, supporting full and partial transparency. Edges, light transmission and refraction are rendered together, so no background removal is required. > [card] Better realism and text > > Lighting, materials and skin texture look closer to real photography, with less overexposure and excessive gloss. Complex glyphs and densely packed small text render noticeably better. > [card] Layer decomposition with OCR > > One image becomes a base plus up to 99 layers. With `text_recognition` enabled, regular text layers return their content, per-line positions and approximate styling. ### Official evaluation: six production scenarios improve ByteDance ran six scenario tests on the MagicArena platform with experienced image evaluators: e-commerce, marketing, film and television, gaming, office productivity, and fashion design. The official conclusion is that Seedream 5.5 beats 5.0 Pro on both quality score and usability rate in all six, with **usability in film/TV and office productivity more than doubling** over the previous generation. A separate GSB study compared text structure and realism. All four comparisons against the previous version were positive, with image-to-image realism reaching **+55.62%**. Against leading models such as GPT Image 2.5 Sunburst and Nano Banana 2.1, ByteDance says Seedream 5.5 leads on text structure and has a clear advantage in text-to-image realism. It also reports severe text corruption down to **0.4%** and minor corruption at **1.7%**. > [!NOTE] > > These figures come from ByteDance Seed's official launch post (9 November 2026) and are vendor self-reported, not an independent third-party rerun. Our own measurements are in the next section. ### APIYI tests: 12–29 seconds, billing matches the official tiers On launch day (13 November 2026, UTC+8) we ran a set of calls with a test token. The main findings: * **Speed**: standard text-to-image takes about 12–29 seconds; a `1K` layer-decomposition request capped at 3 images returned 2 images in about 13.5 seconds * **Size limits**: `2240x2064` and `8592x537` both came back at the requested dimensions; stepping past the total-pixel or aspect-ratio limit returns 400 * **Billing**: `1K` text-to-image \$0.020, `2K` text-to-image \$0.035; `1K` with one reference \$0.028, `2K` with two references \$0.051 * **Layer decomposition**: a `1K` request capped at 3 returned 2 images and billed **2 × \$0.020 + 1 × \$0.008 = \$0.048** * **Not supported**: `n: 2` is silently ignored and still returns one image; `sequential_image_generation` returns 400 for any value ### Technical specifications | Item | Specification | | - | - | | Model ID | `seedream-5-5-261028` | | Endpoint | `POST /v1/images/generations` (generation and editing share it) | | Preset tiers | `1K` / `1.5K` / `2K`; omitting `size` is billed at `2K` | | Custom size | 921,600–4,624,220 total pixels, aspect ratio 1/16–16/1 | | Reference images | Up to 10, as a URL array or a single URL / data URI | | Transparent output | `background: "transparent"` + `output_format: "png"` | | Layer decomposition | Exactly one PNG / JPEG input; `max_images` 2–100, default 30 | | Output format | `png` (default) / `jpeg`; returns `url` or `b64_json` | | Not supported | `quality`, `n`, `sequential_image_generation` | | Measured latency | About 12–29 seconds; set client timeouts to 60 seconds or more | ## Practical Use ### Recommended scenarios * **E-commerce and ad revisions**: outfit, background and scene changes on the same model, refined through multi-turn editing instead of regenerating from scratch * **Design asset production**: transparent PNGs go straight into Figma, Photoshop or video compositing without cutout or edge cleanup * **Poster localization**: decompose layers, read text content and positions through OCR, then swap copy for each language * **Storyboards and game assets**: refine one frame repeatedly without degrading quality, which suits long-running projects **Not ideal for**: print work that needs 3K / 4K (5.5 tops out around 4.62M pixels; use 4.5), or high-volume work where the lowest unit price matters most (5.0 Flash is \$0.018 per request). ### Code example ```python theme={null} from openai import OpenAI client = OpenAI( api_key="sk-your-apiyi-key", base_url="https://api.apiyi.com/v1" ) resp = client.images.generate( model="seedream-5-5-261028", prompt="A perfume hero shot: a transparent glass bottle on a pale stone plinth, side backlight, clean background, 16:9 composition", size="2K", response_format="url", extra_body={ "watermark": False, # always disable for commercial work }, ) print(resp.data[0].url) # URL expires in about 24 hours; download it now ``` For transparent assets, add two parameters to `extra_body`. Note that `jpeg` has no alpha channel, so `png` is required: ```python theme={null} extra_body={ "background": "transparent", "output_format": "png", "watermark": False, } ``` For multi-turn editing, download each output to your own object storage immediately and pass its URL back in the `image` array for the next round. ByteDance recommends RGB input without an alpha channel and `background: "opaque"` for multi-turn work. ### Best practices > [!WARNING] > > **Porting from 5.0 or 4.x? Remove unsupported fields first**: `sequential_image_generation` returns 400 for any value (including `"disabled"`), `n` is silently ignored, and this model has no `quality` parameter. * **Pick the tier deliberately**: `1K` / `1.5K` must be passed explicitly; `2K`, an omitted `size`, and a custom `WxH` all bill at \$0.035 per image * **Reference images are billed separately**: \$0.008 each, so count them before multi-image fusion; 5.0 Flash's free reference images do not carry over * **Layer decomposition bills per actual image**: `max_images` is a ceiling, not a promise, and one input-image fee is added; start with `1K` * **Do not rely on prompts for transparency**: asking for a transparent background in text can produce a painted checkerboard; send `background: "transparent"` with `output_format: "png"` * **Relax timeouts for a synchronous API**: there is no task ID, so a dropped connection loses the result while the request is still billed; widen reverse-proxy and serverless limits too * **Download URL results immediately**: upstream links expire in about 24 hours, so never store them as long-term addresses ## Pricing and Availability ### Pricing | Item | Price | | - | - | | Reference image | **\$0.008 / image** | | Output · 1K / 1.5K | **\$0.020 / image** | | Output · 2K / custom size | **\$0.035 / image** | | Layer decomposition | Billed per returned image, plus one input-image fee | | Failed requests (bad parameters, moderation blocks) | Not billed | Against the rest of the family: a 2K output plus one reference costs about \$0.043, roughly 36% of 5.0 Pro (\$0.12 per request); ByteDance also says 2K square-image editing costs less than half of 5.0 Pro. 5.0 Flash is cheaper at \$0.018 per request but has no native RGBA transparency and no 100-round editing, while 4.5 at \$0.04 per image is the option for 4K. > [!NOTE] > > Prices match the provider and may change with the official price list; the table is a reference, and the **Model Pricing** tab in the top navigation is authoritative: [Model Pricing](https://docs.apiyi.com/en/models/index.md). ### Recharge promotions Model pricing matches BytePlus. Savings come from the [recharge bonus program](https://docs.apiyi.com/en/faq/recharge-promotions.md): up to 20% extra credit on a single top-up, roughly **17% off** effective cash cost. A 1K output at \$0.020 works out to about \$0.0167, and a 2K output at \$0.035 to about \$0.0292. Available groups: `Default`, `SVIP`. ## Summary and Recommendations Seedream 5.5 is not about bigger images. It is about making two things genuinely usable: revising the same image over and over, and taking generated output straight into a design pipeline. Pixel-level preservation across 100 rounds, native RGBA output, and up to 100 decomposition images with text OCR all point at professional workflows. For selection: use `seedream-5-5-261028` for multi-turn revisions, transparent assets and poster localization; keep 5.0 Flash for high-volume low-cost output; use 4.5 when you need 4K print assets. When integrating, remember four things: choose the size tier explicitly, count reference images as billed input, use `background` plus `png` for transparency, and leave 5.0's sequence parameters behind. ByteDance has confirmed that a Pro version of the 5.5 series will follow, with more complex context and creative instructions. We will cover it when it ships. > [!NOTE] > > Sources: ByteDance Seed launch post (9 November 2026) `seed.bytedance.com/en/blog/more-realistic-images-more-stable-editing-across-100-rounds-introducing-seedream-5-5`; BytePlus ModelArk Seedream 5.5 documentation `docs.byteplus.com/en/docs/ModelArk/seedream-5-5`; pricing and measured charges from APIYI calls and the pricing API on 13 November 2026 (UTC+8). This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.