# Seedream v5.5 Layer Decomposition — Atlas Cloud API > ByteDance Seedream 5.5 layer decomposition model that splits one image into an opaque base image plus up to 99 editable transparent PNG layers, with optional rich-text OCR for text layers. This is the machine-readable API reference for **Seedream v5.5 Layer Decomposition** on Atlas Cloud, a unified API platform for 400+ AI models across text, image, video, audio and 3D. - **Model ID**: `bytedance/seedream-v5.5/layer-decomposition` - **Built by**: ByteDance - **Modality**: Image - **Model page**: https://www.atlascloud.ai/models/bytedance/seedream-v5.5/layer-decomposition - **API key**: https://www.atlascloud.ai/console/api-keys - **Docs**: https://www.atlascloud.ai/docs ## Pricing on Atlas Cloud - $0.016 per image - Pay-as-you-go. No minimum spend, no subscription required. > **These are the authoritative Atlas Cloud rates for this model.** Any price that > appears in the vendor description further down refers to a different platform or > a different model variant and does not apply here. ## Use this model from an AI agent Atlas Cloud ships three first-party integration surfaces. All three authenticate with the same API key via the `ATLASCLOUD_API_KEY` environment variable. ### MCP server The official MCP server (`atlascloud-mcp`) exposes this model to any MCP-compatible host — Claude Code, OpenAI Codex, Cursor, Gemini CLI, Goose, Claude Desktop. One-line install: ```bash # Claude Code claude mcp add atlascloud -- npx -y atlascloud-mcp # OpenAI Codex CLI codex mcp add atlascloud -- npx -y atlascloud-mcp # Gemini CLI gemini mcp add atlascloud -- npx -y atlascloud-mcp export ATLASCLOUD_API_KEY="your-api-key" ``` Then ask in plain English; the agent calls `atlas_generate_image` with `model: "bytedance/seedream-v5.5/layer-decomposition"`. The server fetches each model's schema and validates parameters before submitting, so invalid requests fail fast without spending credits. MCP docs: https://www.atlascloud.ai/docs/mcp-server ### Agent Skills `atlas-cloud-skills` is a portable skill package (API reference, code templates in Python / Node.js / cURL, model IDs with pricing) for Claude Code, Cursor, Codex and 12+ other agents: ```bash npx skills add AtlasCloudAI/atlas-cloud-skills export ATLASCLOUD_API_KEY="your-api-key" ``` Skills docs: https://www.atlascloud.ai/docs/skills ### CLI The `atlas` binary runs Atlas Cloud from a terminal or CI script. Async media jobs are polled and downloaded automatically (use `--no-download` when a script only needs the output URLs): ```bash # Install (Homebrew, npm, or shell installer) brew install AtlasCloudAI/tap/atlascloud # npm install -g atlascloud-cli # curl -fsSL https://raw.githubusercontent.com/AtlasCloudAI/cli/main/install.sh | sh atlas auth login atlas generate image bytedance/seedream-v5.5/layer-decomposition -p "Your prompt here" ``` CLI docs: https://www.atlascloud.ai/docs/cli ## HTTP API reference - **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateImage` — start an async generation; returns a `prediction_id` - **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes - **Model ID**: `bytedance/seedream-v5.5/layer-decomposition` ## API Information This model can be used via our HTTP API or more conveniently via our client libraries. See the input and output schema below, as well as the usage examples. ### Input Schema The API accepts the following input parameters: - **`model`** (`string`, _required_): model name - Default: `"bytedance/seedream-v5.5/layer-decomposition"` - **`image`** (`string`, _required_): The image to decompose into layers. Exactly one PNG or JPEG image, at most 30MB, with total pixels within [512*512, 6000*6000] and aspect ratio (width / height) within [1/16, 16]. Supports both a public URL and a base64-encoded image (e.g., data:image/png;base64,). - **`prompt`** (`string`, _optional_): Optional instruction describing which elements to split into layers. Leave empty to let the model automatically split the main elements (subjects, background, text, ...). Targets can be described in natural language or pinpointed with x1 y1 x2 y2 tags using coordinates normalized to [0, 1000] (origin at the top-left corner). If the prompt asks for more layers than num_images allows, some layer information may be lost. - **`resolution`** (`string`, _optional_): Output resolution tier of the base image and each layer; every output keeps its own aspect ratio from the original image. 'auto' (default) follows the original size of the base image and of each layer: sizes within [1280*720 (921,600), 2048*2048*1.1025 (4,624,220)] pixels are kept as-is, smaller ones are output at 1k, and larger ones at 2k. - Default: `"auto"` - Options: "auto", "1k", "1.5k", "2k" - **`num_images`** (`integer`, _optional_): Maximum total number of output images, counting the base image and the layers (i.e., 1 base image + up to 99 layers). This is an upper bound, not a guaranteed count: when the prompt does not say how to split, the model plans the split from this value and the complexity of the input image, and a larger value usually gives finer layers. - Default: `30` - Min: 2 - Max: 100 - **`enable_text_recognition`** (`boolean`, _optional_): If enabled, layers containing regular text additionally return a rich-text OCR result in layers[].text_recognition: the full text, per-line bounding boxes, and style runs (similar font, color, bold, italic, underline, strikethrough, shadow, translucency). Only regular text in 101 common Chinese and 127 common non-Chinese fonts is recognized; non-text layers and artistic or handwritten text return no OCR result. - Default: `false` - **`output_format`** (`string`, _optional_): File format of the base image only. Decomposed layers are always transparent PNG. - Default: `"png"` - Options: "png", "jpeg" - **`enable_sync_mode`** (`boolean`, _optional_): If set to true, the function will wait for the result to be generated and uploaded before returning the response. It allows you to get the result directly in the response. This property is only available through the API. - Default: `false` - **`enable_base64_output`** (`boolean`, _optional_): If enabled, the output will be encoded into a BASE64 string instead of a URL. This property is only available through the API. - Default: `false` **Required Parameters Example**: ```json { "model": "bytedance/seedream-v5.5/layer-decomposition", "image": "" } ``` **Full Example**: ```json { "model": "bytedance/seedream-v5.5/layer-decomposition", "image": "", "prompt": "", "resolution": "auto", "num_images": 30, "enable_text_recognition": false, "output_format": "png", "enable_sync_mode": false, "enable_base64_output": false } ``` ### Output Schema The API returns the following output format: - **`id`** (`string`, _optional_): Unique identifier for the prediction. - **`model`** (`string`, _optional_): Model ID used for the prediction. - **`status`** (`string`, _optional_): Status of the task: created, processing, completed, or failed. - **`outputs`** (`array[string]`, _optional_): URLs of the generated images: the base image first, then each decomposed layer in ascending z-order (up to 1 base + 99 layers, bounded by num_images). Empty when status is not completed. - **`image_results`** (`array[object]`, _optional_): Per-output image metadata, index-aligned with outputs (image_results[i] describes outputs[i]). Empty when status is not completed. - Item properties: - **`background`** (`string`, _optional_): The background type of this output image. The base image is always opaque; every decomposed layer is always transparent. - Options: "transparent", "opaque" - **`layers`** (`array[object]`, _optional_): Per-output layer metadata, index-aligned with outputs (layers[i] describes outputs[i]). The base image entry has z_index 0 and no bounding box, name, description, or text recognition. - Item properties: - **`z_index`** (`integer`, _optional_): Stacking order from the bottom up: 0 is the base image; larger values sit higher. Compositing layers by ascending z_index inside their bounding boxes reconstructs the full image. - **`bounding_box`** (`object`, _optional_): The region this layer occupies within the base image. Absent on the base image entry. - Properties: - **`absolute`** (`array[integer]`, _optional_): [x1, y1, x2, y2] pixel coordinates of the top-left and bottom-right corners in the output base image's coordinate system (origin at top-left, x right, y down). - **`normalized`** (`array[integer]`, _optional_): [x1, y1, x2, y2] quantized to the [0, 1000] range, proportional to the base image size. - **`name`** (`string`, _optional_): Model-generated label of the layer's subject. Absent on the base image entry. - **`description`** (`string`, _optional_): Model-generated description of the layer (color, state, material, ...). Absent on the base image entry. - **`text_recognition`** (`object`, _optional_): Structured rich-text OCR result of this text layer. Only returned when enable_text_recognition is true and the model judges the layer's text to be regular text; absent on the base image, on non-text layers, and on layers with artistic or handwritten text. - Properties: - **`text`** (`string`, _optional_): Full plain text of the layer: the lines in top-to-bottom, left-to-right order joined with a line break (\n), e.g. "50% OFF TODAY ONLY\nFLASH SALE". - **`lines`** (`array[object]`, _optional_): Recognized text lines in reading order; one entry per line. - Item properties: - **`bounding_box`** (`object`, _optional_): The region this text line occupies in the output base image's coordinate system; can be used to place the recognized text back onto the base image or a target canvas. - Properties: - **`absolute`** (`array[integer]`, _optional_): [x1, y1, x2, y2] pixel coordinates of the top-left and bottom-right corners in the output base image's coordinate system (origin at top-left, x right, y down). - **`normalized`** (`array[integer]`, _optional_): [x1, y1, x2, y2] quantized to the [0, 1000] range, proportional to the base image size. - **`runs`** (`array[object]`, _optional_): Style runs of this line. A line with a uniform style has a single run; it is split into several runs where the font, color, weight or other style changes. - Item properties: - **`text`** (`string`, _optional_): Text of this run, without line breaks. - **`style`** (`object`, _optional_): Approximate visual style detected by the model; it may deviate from the exact attributes in the original design file. - Properties: - **`similar_font_family`** (`string`, _optional_): Name of the most similar font matched from the text's appearance (101 common Chinese and 127 common non-Chinese fonts are supported). Not guaranteed to be the original font; "unknown" when the font cannot be identified with enough confidence. - **`foreground_color`** (`string`, _optional_): Text color as an uppercase hex string in #RRGGBB format, without an alpha channel (e.g., "#E53935"). - **`bold`** (`boolean`, _optional_): Whether the run is detected as bold. - **`italic`** (`boolean`, _optional_): Whether the glyphs themselves are detected as slanting to the right. Rotation or perspective skew of the whole layer does not count as italic. - **`underline`** (`boolean`, _optional_): Whether the run is detected as having a text underline. Standalone dividers, table lines or decorative rules do not count. - **`strikethrough`** (`boolean`, _optional_): Whether the run is detected as having a strikethrough. - **`shadow`** (`boolean`, _optional_): Whether the run is detected as having a visible drop shadow, glow or offset shadow. Normal anti-aliased edges do not count. - **`translucent`** (`boolean`, _optional_): Whether the text ink itself is detected as visibly semi-transparent, letting the background texture or color show through. Solid light-colored text (light gray, light blue, ...) does not count. - **`urls`** (`object`, _optional_): Object containing related API endpoints. - **`created_at`** (`string`, _optional_): ISO timestamp of when the request was created. **Example Response**: ```json { "id": "", "model": "", "status": "", "outputs": [ "" ], "image_results": [ { "background": "transparent" } ], "layers": [ { "z_index": 0, "bounding_box": { "absolute": [], "normalized": [] }, "name": "", "description": "", "text_recognition": { "text": "", "lines": [ { "bounding_box": { "absolute": [], "normalized": [] }, "runs": [ { "text": "", "style": { "similar_font_family": "", "foreground_color": "", "bold": false, "italic": false, "underline": false, "strikethrough": false, "shadow": false, "translucent": false } } ] } ] } } ], "urls": {}, "created_at": "" } ``` ## Usage Examples ### cURL ```bash # Step 1: Start generation (async) curl -X POST "https://api.atlascloud.ai/api/v1/model/generateImage" \ -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "bytedance/seedream-v5.5/layer-decomposition", "image": "", "prompt": "", "resolution": "auto", "num_images": 30, "enable_text_recognition": false, "output_format": "png", "enable_sync_mode": false, "enable_base64_output": false }' # Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}} # Step 2: Poll for result (replace {prediction_id} with the id returned above) curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \ -H "Authorization: Bearer $ATLASCLOUD_API_KEY" # Keep polling until status is "completed", "succeeded" or "failed" # When completed, outputs will contain the generated content URL(s) ``` ## Additional Resources ### Documentation - [Model Playground](https://www.atlascloud.ai/models/bytedance/seedream-v5.5/layer-decomposition) ## About this model _Vendor-supplied description. Any pricing or endpoint mentioned below refers to_ _other platforms — use the Atlas Cloud values above._ #### ByteDance Seedream 5.5 — Layer Decomposition **Seedream 5.5** (version 261028, October 2026) is the latest image generation and editing model from ByteDance's Seed team and the successor to Seedream 5.0 Pro. ByteDance positions it as a **production-grade "AI Photoshop"** and alongside the world's leading image models. A single model generates images, keeps them consistent through many rounds of editing, outputs native transparent (RGBA) images, and splits a finished image back into editable layers. Compared with Seedream 5.0 Pro, it improves photorealism, aesthetics and editing consistency. It supports continuous multi-round editing while keeping non-edited areas stable, and it adds three new capabilities: **native RGBA output**, **layer decomposition into up to 100 images**, and **rich-text OCR** of regular text. This **Layer Decomposition** endpoint takes **one image** and splits it into **an opaque base image plus up to 99 transparent PNG layers**, such as subjects, decorative elements and text. It runs the same Seedream 5.5 model as the Text-to-Image and Edit endpoints; only the inputs differ. Each layer comes back with its stacking order, its bounding box in the base image, a name and a description, so you can rebuild the full image or edit any layer on its own. Set `num_images` to control how many outputs to allow, which in turn controls how finely the image is split. Turn on `enable_text_recognition` to get rich-text OCR for layers with regular text: the full text, line positions, similar font, color and styling. Together, these turn a flat poster back into an editable, layered design. #### 🌟 What's New in Seedream 5.5 _(Description truncated. Full text on the model page.)_ --- Atlas Cloud — one API for 400+ AI models. Model page: https://www.atlascloud.ai/models/bytedance/seedream-v5.5/layer-decomposition · Docs: https://www.atlascloud.ai/docs