---
title: "Layerize Image"
description: "Break a flat image into its objects, each as its own transparent layer, plus a background plate with the holes filled."
updated: 2026-07-29
---

# Layerize Image

**Badge:** New  
**Node type:** `process:layerize_image`  
**Category:** `process`

## Description

Break a flat image into its objects, each as its own transparent layer, plus a background plate with the holes filled.

## Pricing

- **Cost:** ~16 credits per images

## Canvas ports

These appear as port handles on the left side of the node.

| ID      | Label     | Details              |
| ------- | --------- | -------------------- |
| `image` | **Image** | `IMAGE` _(required)_ |

## Sidebar config

These render as form fields in the right-side config panel when the node is selected.

| ID            | Label            | Details   |
| ------------- | ---------------- | --------- |
| `maxLayers`   | **Max layers**   | `NUMBER`  |
| `labelLayers` | **Label layers** | `BOOLEAN` |

## Outputs

| ID        | Label                | Type    |
| --------- | -------------------- | ------- |
| `layers`  | **Layers (JSON)**    | `JSON`  |
| `plate`   | **Background plate** | `IMAGE` |
| `preview` | **Layers preview**   | `IMAGE` |
| `stage`   | **Source size**      | `JSON`  |

## Wire `layers` into a Compositor

This node's whole point is the **Layers (JSON)** output. Connect it to a
**Compositor**'s `Layers (JSON)` input and every object becomes a separate,
draggable layer in the compositor editor. Connect **Background plate** to the
Compositor's `Background` input in the same move, or the objects float on
nothing.

```
Image  ->  Layerize Image  --Layers (JSON)-->  Compositor
                           --Background plate-->
```

Leave the Compositor's own layer list empty. The layers arrive over the wire, so
the canvas shows where they came from, and re-running Layerize refreshes them in
place.

## Objects come back whole

Layers are semantic, not just visually separated. An open laptop comes back as
one laptop rather than a screen and a body. More usefully, an object that was
partly hidden is **reconstructed**: a notebook with a plant sitting on it comes
out as a complete notebook, so you can move either one and nothing has a bite
taken out of it.

The background plate is generated the same way, with every object removed, so
sliding a layer aside reveals a clean backdrop instead of a hole.

## Layers are named

A short naming pass labels each layer, so the panel reads "laptop", "coffee mug",
"spiral notebook" instead of numbers. Turn it off with **Label layers** to shave a
few seconds off the run. It does not change the price: the node costs the same
flat amount either way. Naming never fails a run: if it does
not come back cleanly the layers ship numbered.

## What the node itself shows

The node's own thumbnail is a grid of the objects it cut, so you can tell at a
glance what it separated without opening the compositor. The **Background plate**
output is a different image: the backdrop with everything removed. That one is
nearly empty by design, which is why it is not what the card displays.

## Your edits survive a re-run

Drag a layer in the compositor and that position is yours: a later Layerize run
updates the layer's image but keeps where you put it. Scale, rotation, opacity,
visibility and lock behave the same. Only layers you have never touched adopt the
new position, so you can re-run after changing the source without losing your
composition.

## Max layers is a ceiling, not a target

Asking for more layers does not find more objects, it splits the ones already
found and starts returning the same object twice. Near-duplicates are merged
automatically and the node tells you when it merged any, but the setting is best
left near its default. Raising it costs nothing extra; the price is flat per
image no matter how many layers come out.

## Full resolution

Layers are cut from your original image, not from the decomposition model's
smaller working copy, so a 2048px source gives 2048px layers. Images larger than
2048px on the long edge are worked at 2048 to bound memory, and the node says so.

---

_Auto-generated from the Wireflow node registry._

---

Documentation index: fetch https://www.wireflow.ai/llms.txt for the full list of Wireflow docs.