GPT Image 2.5 Flare & Sunburst are live on EvoLinkTry GPT Image 2.5
Skip to article
Concept illustration of an ivory design separated into transparent sheets with a blue object and coral accent
Tutorial

Seedream 5.5 Layer Decomposition: Rebuild and Edit a Design

Reassemble Seedream 5.5 PNG layers with bounding boxes and stacking order, turn available OCR into editable text, and review a design before making variants.

JessieCOO
11 min read

Seedream 5.5 layer decomposition returns a base image, transparent PNG layers and placement metadata. To turn those outputs into an editable design, your application must resize and position each layer, preserve stacking order, and create text objects from any available OCR. Downloading the PNGs is the start of that work.

This guide is for engineers building ad variants, localized posters or design-editing tools through EvoLink. It follows the documented route as of November 13, 2026. The illustrations use an attributed BytePlus example and explanatory diagrams; they are not EvoLink API test results. If you only need one reusable cutout, use the transparent PNG guide instead.

Decide what should remain editable

Start with one approved poster and one concrete change: move a product, replace a heading or create another language version. The output you need depends on that change.

DeliverableWhat it lets you changeWork your application still owns
One transparent PNGPosition of the whole imageComposition and export
Base image plus PNG layersPosition and visibility of separated elementsScaling, placement, stacking and inspection
Layers plus rich-text OCRRecognized text and approximate styleNative text objects, font mapping, layout and saving
Layer decomposition is not a direct PSD export or recovery of the original authoring file. Several objects may share a layer, and text may remain raster artwork. Confirm that the element you intend to change is separate before building a workflow around it. The model selection section explains when to choose ordinary generation versus Layerize.

Request the parts your workflow needs

On EvoLink, use doubao-seedream-5.5-layerize with exactly one accessible PNG or JPEG input. Ordinary generation accepts different inputs; do not carry its multi-reference setup into this route. Keep your key on the server.
For an initial inventory, omit the optional prompt and request OCR with model_params.text_recognition: true. If you need specific elements, use the documented natural-language or bbox targeting rather than assuming every visible object will be isolated. OCR remains optional in the response, even when requested.
curl -X POST https://api.evolink.ai/v1/images/generations \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seedream-5.5-layerize",
    "image_urls": ["YOUR_PUBLIC_IMAGE_URL"],
    "quality": "auto",
    "output_format": "png",
    "n": 30,
    "model_params": {"text_recognition": true}
  }'
Replace YOUR_PUBLIC_IMAGE_URL with a server-accessible image URL. n: 30 is a maximum including the base image, not a promise of 30 outputs. EvoLink accepts n from 2 to 100; fewer images may be returned. Resolution uses quality: auto, 1K, 1.5K or 2K, not an aspect ratio such as 16:9.
Save the returned task id, then query GET /v1/tasks/{task_id} until completion or handle failure. Read the actual result_data, not a fixed-length array. If one layer fails, the documented route fails the whole request and refunds it. Save completed files promptly: result links are valid for 24 hours. See the Layerize API documentation for the complete contract.

Reassemble Seedream 5.5 PNG layers

The base image has z_index: 0. Higher values go above it. Layer placement comes from bounding_box, using the output base image as the coordinate reference. The input poster and the layer file itself are not interchangeable coordinate systems.
Official BytePlus poster, base image and reconstructed composition
Official BytePlus poster, base image and reconstructed composition
An official BytePlus Seedream 5.5 example: input on the left, base image in the middle, and a local composition of the supplied PNG layers on the right. Display panels are resized. This is file composition of an official sample, not an EvoLink generation test or a claim of pixel-identical recovery.
For a box [left, top, right, bottom], its display width is right - left, and its height is bottom - top. Resize the layer to that rectangle, then place it at (left, top). Do not interpret the final two values as width and height, or paste every downloaded layer at its native dimensions.
For example, the official sample's presenter layer is a 1166×899 file, while its base-image rectangle is [1142, 528, 1474, 784]: 332×256 pixels. This illustrates why the file dimensions alone cannot restore the layout. It is a property of that published sample, not a measured output guarantee.
The following local manifest is an application adapter, not an API response. After downloading your files, map the base image and each layer's file, box and z_index into this shape. The coordinates are illustrative; replace them with your own result metadata.
The task documentation uses results for image URLs, while the Layerize description adds placement and OCR in result_data. Save the complete response and download the files, then establish a verifiable file-to-metadata association before building this manifest. Select the base by z_index: 0, not a guessed filename. Do not invent an index-based join between collections unless the current response contract defines it; inspect the actual task documentation if the association is unclear. No EvoLink generation request was executed for this guide; only local sample-file composition was run.
{
  "base": "base.png",
  "layers": [
    {"file": "layer-1.png", "box": [120, 80, 420, 280], "z": 1}
  ]
}
Install Pillow with python -m pip install pillow. Save the next block as reassemble.py, place layers.json and the images together, and run python reassemble.py layers.json. It checks local geometry and stacking, then exports a visual preview. It does not reconstruct editable text or certify model quality.
import json
import sys
from pathlib import Path
from PIL import Image

manifest = Path(sys.argv[1])
data = json.loads(manifest.read_text())
root = manifest.parent
with Image.open(root / data["base"]) as image:
    canvas = image.convert("RGBA")
width, height = canvas.size
layers = data["layers"]
orders = [item["z"] for item in layers]
if any(type(z) is not int or z <= 0 for z in orders):
    raise ValueError("Layer order must be a positive integer")
if len(set(orders)) != len(orders):
    raise ValueError("Duplicate layer order")
for item in sorted(layers, key=lambda layer: layer["z"]):
    box = item["box"]
    if len(box) != 4 or any(type(v) is not int for v in box):
        raise ValueError("Expected four integer box coordinates")
    left, top, right, bottom = box
    if not (0 <= left < right <= width and 0 <= top < bottom <= height):
        raise ValueError("Box outside the base image or empty")
    with Image.open(root / item["file"]) as image:
        layer = image.convert("RGBA").resize(
            (right - left, bottom - top), Image.Resampling.LANCZOS
        )
    canvas.alpha_composite(layer, dest=(left, top))
canvas.save(root / "reassembled.png")
Stop for inspection if a layer has no trustworthy box, a duplicate order or invalid coordinates. Do not silently place it at the origin. Preserve each PNG's alpha while resizing and compositing; inspect halos and thin structures using the alpha and edge checks.

Turn OCR into editable text

For regular text layers, text_recognition can contain the full text, lines, per-line bounding_box and styled runs. The official guide defines those line boxes in base-image coordinates too. Do not offset them again by the parent layer's position.
Use the recognized text as a starting point. Check wording and reading order, map similar_font_family to an available licensed font, and apply foreground_color and the style flags your editor supports. The font match and attributes are estimates. Artistic or handwritten text can have no OCR; absence should lead to a manual text step or retaining the image layer.

When replacing a text layer with native text, hide its raster counterpart so the old and new letters do not overlap. If one raster layer contains several lines and you replace only one, mask or remove just that line while preserving the others. Alternatively, rebuild all text you need before hiding the whole raster layer. Save text objects, font choices and layout in your application document. OCR data by itself is not a saved editable design.

If similar_font_family is unknown, choose an explicit fallback with the required glyphs and licensing, then review the fit. A style flag set to false means the model did not recognize that style; it does not prove the original lacks it. Treat these values as recognition hints, not exact design attributes.

Adapt the design without distorting it

Diagram of base-image coordinates and a second layout
Diagram of base-image coordinates and a second layout
Coordinate schematic, not model output. A uniform scale preserves relative positions; a new aspect ratio requires a layout decision.
For the same aspect ratio, apply one scale to the entire composition. With normalized boxes, calculate x = normalized_x × target_width / 1000 and y = normalized_y × target_height / 1000 for both corners. With absolute boxes, scale from the actual output base dimensions. Use one consistent coordinate path throughout.

A square poster converted to a tall ad needs more than coordinate multiplication. Choose whether to fit the old design with margins, crop it, or rearrange its elements. Independent horizontal and vertical scaling can stretch products and type. Moving an object can also reveal imperfect reconstructed background content; inspect the newly exposed area instead of assuming it is the original hidden scene.

For a language variant, replace one heading first. Check glyph coverage, line breaks, text-box height, visual hierarchy and overlap with foreground objects. Keep source and edited states separate so a reviewer can compare them. Translation and reflow are application work, not an automatic consequence of receiving OCR.

Review the result before making more variants

SymptomCheck firstNext step
Oversized or misplaced layerBox convention, base dimensions and file-to-box resizingFix the composition transform before another model request
Incorrect overlapAscending z_index and retained visibilityRestore the intended stack
Double text or missing linesRaster text visibility and replacement scopeKeep one deliberate representation of each line
Missing OCR or inaccurate stylingWhether the layer is regular text; actual OCR fieldsUse manual text reconstruction or keep the raster layer

Review the reconstructed source before changing it, then inspect the edited result at its delivery size. Check product identity, edges, background fill, occlusion, wording and final export. Coordinate-correct placement does not establish pixel-perfect reconstruction or acceptable design quality.

Budget for actual output images. EvoLink documents a reservation for one input plus n outputs at the 2K rate, with final settlement based on the images produced and their pixel tiers. A larger cap can reserve more balance without being necessary for the edit. Use the existing pricing section; this guide does not duplicate its rate table.
For the next task, open Seedream 5.5 Layerize. EvoLink keeps model selection, keys, balance and asynchronous task handling in the same integration; your application owns composition, editable documents and review.

Frequently asked questions

Does Seedream 5.5 return a PSD?

The documented EvoLink route returns images and metadata, not a native PSD. An editor or exporter must build the design document.

Does n: 30 mean 30 separate foreground layers?

No. It caps all output images, including the base. The actual count may be lower; read the returned items.

Should I use the layer PNG's original size?

Use its base-image bounding box for placement. The file can be larger than that rectangle, so resize it before compositing.

Can I rebuild from normalized coordinates?

Yes, convert each corner from the 0–1000 coordinate range using the target canvas dimensions. Changing aspect ratio still requires an explicit fit, crop or reflow choice.

Will every text layer contain OCR?

No. Request recognition, then check whether text_recognition exists. Regular text is supported; stylized and handwritten lettering may need manual work.

Does OCR identify the exact original font?

No. similar_font_family is an approximate match, not proof of font identity or licensing. Choose an available font and inspect the result.

Should I regenerate when layers are misaligned?

First check stacking, box interpretation and scaling. Those composition mistakes can be corrected locally. Missing or unusable visual content may need editing or another decomposition.

No. They explain the documented workflow using an official sample and local file operations. They do not measure API success rate, reconstruction fidelity or speed.

Sources

Connect AI models through one API

Compare models and current pricing, then follow the API documentation to integrate your chosen model.