---
title: Postprocessing with Reve 2.1 — Reve 2.1 | Runware Docs
url: https://runware.ai/docs/models/reve-2-1/guides/postprocessing
description: How to use settings.postprocessing on Reve 2.1 to run a pipeline over the model output, and when to reach for removeBackground for cutout deliverables.
---
### [Introduction](https://runware.ai/docs/models/reve-2-1/guides/postprocessing#introduction)

The Reve 2.1 request accepts a `settings` object, and one of its optional fields is `postprocessing`. It takes an **array of step objects**, each with a `type`, and each entry runs on the model output before the response lands. The array shape means the field declares a pipeline rather than a single flag, so `imageURL` in the response reflects what the pipeline produced rather than the raw model render.

Postprocessing is scoped to **Reve's own set of step names**. Each name maps to a specific action the pipeline knows how to run, and unknown names are rejected at request validation rather than silently ignored. This guide walks through the request shape, and then covers `removeBackground` and how postprocessing composes with reference edits and remixes.

### [Request shape](https://runware.ai/docs/models/reve-2-1/guides/postprocessing#request-shape)

`settings.postprocessing` is set as an array on the request. Each entry is an object with one required field: `type`, the step name.

TypeScriptPythoncURLCLIJSON

```typescript
import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'reve:2@1',
  positivePrompt: 'A single bright red high-top canvas sneaker with a white rubber sole and a white cap toe, standing at a three-quarter angle on a warm cream studio backdrop with soft directional light from the upper left.',
  width: 4096,
  height: 4096,
  outputFormat: 'PNG',
  settings: {
    postprocessing: [
      {
        type: 'removeBackground'
      }
    ]
  }
})
```

```python
import asyncio
import os

from runware import Runware

async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "reve:2@1",
            "positivePrompt": "A single bright red high-top canvas sneaker with a white rubber sole and a white cap toe, standing at a three-quarter angle on a warm cream studio backdrop with soft directional light from the upper left.",
            "width": 4096,
            "height": 4096,
            "outputFormat": "PNG",
            "settings": {
                "postprocessing": [
                    {
                        "type": "removeBackground"
                    }
                ]
            }
        })

asyncio.run(main())
```

```bash
curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "imageInference",
      "taskUUID": "b2c3d4e5-f6a7-8901-bcde-f23456789012",
      "model": "reve:2@1",
      "positivePrompt": "A single bright red high-top canvas sneaker with a white rubber sole and a white cap toe, standing at a three-quarter angle on a warm cream studio backdrop with soft directional light from the upper left.",
      "width": 4096,
      "height": 4096,
      "outputFormat": "PNG",
      "settings": {
        "postprocessing": [
          {
            "type": "removeBackground"
          }
        ]
      }
    }
  ]'
```

```bash
runware run reve:2@1 \
  positivePrompt="A single bright red high-top canvas sneaker with a white rubber sole and a white cap toe, standing at a three-quarter angle on a warm cream studio backdrop with soft directional light from the upper left." \
  width=4096 \
  height=4096 \
  outputFormat=PNG \
  settings.postprocessing.0.type=removeBackground
```

```json
{
  "taskType": "imageInference",
  "taskUUID": "b2c3d4e5-f6a7-8901-bcde-f23456789012",
  "model": "reve:2@1",
  "positivePrompt": "A single bright red high-top canvas sneaker with a white rubber sole and a white cap toe, standing at a three-quarter angle on a warm cream studio backdrop with soft directional light from the upper left.",
  "width": 4096,
  "height": 4096,
  "outputFormat": "PNG",
  "settings": {
    "postprocessing": [
      {
        "type": "removeBackground"
      }
    ]
  }
}
```

Response

```json
[
  {
    "taskType": "imageInference",
    "taskUUID": "b2c3d4e5-f6a7-8901-bcde-f23456789012",
    "imageUUID": "7d8e9f0a-1b2c-3d4e-5f6a-7b8c9d0e1f2a",
    "imageURL": "https://im.runware.ai/image/os/a14d18/ws/2/ii/7d8e9f0a-1b2c-3d4e-5f6a-7b8c9d0e1f2a.png"
  }
]
```

A few things worth knowing beyond the parameter list:

- The array is optional. **Omit `settings.postprocessing`** for a plain render at the raw model output.
- Each entry is an object of the form `{ "type": "<stepName>" }`. Unknown names fail at request validation rather than skipping through.
- **Set `outputFormat` to `PNG` or `WEBP`** when running `removeBackground`. The default `JPG` has no alpha channel, so the cutout flattens onto a solid backdrop rather than returning transparent pixels.

Full parameter constraints (allowed step names, per-step config) live in the [Reve 2.1 model reference](https://runware.ai/docs/models/reve-2-1).

### [`removeBackground`](https://runware.ai/docs/models/reve-2-1/guides/postprocessing#removebackground)

Add `{ type: "removeBackground" }` to the pipeline and Reve returns the generated image with an **alpha cutout in place of the backdrop**. The rest of the request stays identical to a plain render.

![A single bright red high-top canvas sneaker with a white rubber sole standing at a three-quarter angle on a warm cream studio backdrop](https://runware.ai/docs/assets/output-cutout-rendered.Bpt6UvV1_Z8UWDe.jpg)

*Plain render, backdrop intact*

> **Prompt**: A single bright red high-top canvas sneaker with a white rubber sole and a white cap toe, laces neatly done up, standing at a three-quarter angle on a warm cream studio backdrop with soft directional light from the upper left casting a subtle shadow behind the heel. Photoreal editorial product packshot, no text, no other objects, no other footwear.

![The same bright red high-top sneaker isolated with the warm cream studio backdrop cut out to alpha](https://runware.ai/docs/assets/output-cutout-alpha.CWHc3FjI_KNuYK.jpg)

*Same request, removeBackground applied*

> **Prompt**: A single bright red high-top canvas sneaker with a white rubber sole and a white cap toe, laces neatly done up, standing at a three-quarter angle on a warm cream studio backdrop with soft directional light from the upper left casting a subtle shadow behind the heel. Photoreal editorial product packshot, no text, no other objects, no other footwear.

Both images came from the same positive prompt. Reve has **no `seed` field**, so two calls of the same request still produce different renders rather than an identical pair.

The **left is the raw render** and the right was returned by the same request with `settings.postprocessing` added. The studio backdrop drops out cleanly around the sneaker's outline and around the negative space between the laces. The alpha output is ready to drop onto a designed page or a photo composite without a manual mask.

`removeBackground` segments the foreground of the rendered scene. When the prompt puts a **single hero subject** on a plain backdrop, the split lands clean and the alpha traces the subject's outline.

### [Layering onto edits and remixes](https://runware.ai/docs/models/reve-2-1/guides/postprocessing#layering-onto-edits-and-remixes)

`settings.postprocessing` works on any Reve 2.1 request, **not only plain text-to-image**. Attach the settings object to an edit or a remix alongside the existing `inputs.referenceImages` and the pipeline runs on the final composited render, so a multi-reference composition returns as a cutout of the composed scene rather than a stack of separate cutouts.

TypeScriptPythoncURLCLIJSON

```typescript
import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'reve:2@1',
  positivePrompt: 'The caramel-brown pebbled leather crossbody handbag from <frame>0</frame> worn by a woman in a cream trench coat walking down a sunlit Parisian side street.',
  inputs: {
    referenceImages: [
      'https://im.runware.ai/image/os/a14d18/ws/2/ii/f4e3d2c1-b0a9-8765-4321-fedcba098765.jpg'
    ]
  },
  width: 4096,
  height: 4096,
  outputFormat: 'PNG',
  settings: {
    postprocessing: [
      {
        type: 'removeBackground'
      }
    ]
  }
})
```

```python
import asyncio
import os

from runware import Runware

async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "reve:2@1",
            "positivePrompt": "The caramel-brown pebbled leather crossbody handbag from <frame>0</frame> worn by a woman in a cream trench coat walking down a sunlit Parisian side street.",
            "inputs": {
                "referenceImages": [
                    "https://im.runware.ai/image/os/a14d18/ws/2/ii/f4e3d2c1-b0a9-8765-4321-fedcba098765.jpg"
                ]
            },
            "width": 4096,
            "height": 4096,
            "outputFormat": "PNG",
            "settings": {
                "postprocessing": [
                    {
                        "type": "removeBackground"
                    }
                ]
            }
        })

asyncio.run(main())
```

```bash
curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "imageInference",
      "taskUUID": "c3d4e5f6-a7b8-9012-cdef-345678901234",
      "model": "reve:2@1",
      "positivePrompt": "The caramel-brown pebbled leather crossbody handbag from <frame>0</frame> worn by a woman in a cream trench coat walking down a sunlit Parisian side street.",
      "inputs": {
        "referenceImages": [
          "https://im.runware.ai/image/os/a14d18/ws/2/ii/f4e3d2c1-b0a9-8765-4321-fedcba098765.jpg"
        ]
      },
      "width": 4096,
      "height": 4096,
      "outputFormat": "PNG",
      "settings": {
        "postprocessing": [
          {
            "type": "removeBackground"
          }
        ]
      }
    }
  ]'
```

```bash
runware run reve:2@1 \
  positivePrompt="The caramel-brown pebbled leather crossbody handbag from <frame>0</frame> worn by a woman in a cream trench coat walking down a sunlit Parisian side street." \
  inputs.referenceImages.0=https://im.runware.ai/image/os/a14d18/ws/2/ii/f4e3d2c1-b0a9-8765-4321-fedcba098765.jpg \
  width=4096 \
  height=4096 \
  outputFormat=PNG \
  settings.postprocessing.0.type=removeBackground
```

```json
{
  "taskType": "imageInference",
  "taskUUID": "c3d4e5f6-a7b8-9012-cdef-345678901234",
  "model": "reve:2@1",
  "positivePrompt": "The caramel-brown pebbled leather crossbody handbag from <frame>0</frame> worn by a woman in a cream trench coat walking down a sunlit Parisian side street.",
  "inputs": {
    "referenceImages": [
      "https://im.runware.ai/image/os/a14d18/ws/2/ii/f4e3d2c1-b0a9-8765-4321-fedcba098765.jpg"
    ]
  },
  "width": 4096,
  "height": 4096,
  "outputFormat": "PNG",
  "settings": {
    "postprocessing": [
      {
        "type": "removeBackground"
      }
    ]
  }
}
```

The workflow this lines up for is a **product-in-scene render with a cutout deliverable**. The reference features carry the subject identity while the remix prose builds the scene around it, and the postprocessing step turns the composited render into an alpha output in the same call. See the [reference editing and remixing guide](https://runware.ai/docs/models/reve-2-1/guides/reference-editing-remixing) for the reference-side patterns that pair with this.

### [Known limits](https://runware.ai/docs/models/reve-2-1/guides/postprocessing#known-limits)

`removeBackground` **segments the foreground** rather than following a supplied mask. There is no field for "cut around this specific object" or "use this alpha channel as the segmentation." The result depends on the pipeline's own read of the rendered scene, so a composed shot with two prominent subjects returns a cutout of both together rather than one at a time.

The pipeline runs on the model's output, **not on the prompt**. It does not go back and re-render the scene without the backdrop, so a subject that is partly obscured in the rendered scene stays partly obscured in the cutout. Draft the source prompt so the subject reads clean before postprocessing, not the other way around.

### [Tips](https://runware.ai/docs/models/reve-2-1/guides/postprocessing#tips)

1. **Use `removeBackground` for cutout deliverables.** The setting exists for outputs that land in a design tool or a page composite. Skip it on runs that ship as complete rendered images.
    
2. **Match the prompt to what you want isolated.** `removeBackground` cuts what it judges to be the foreground group. When the deliverable is one hero subject, keep the prompt focused on that subject and let the backdrop stay generic.
    
3. **Treat the `.png` response like a `.jpg`.** The URL in `imageURL` still points at the delivered file. The file just carries an alpha channel now.
    
4. **Compose with reference features when needed.** A signed-off product packshot goes into `inputs.referenceImages`, gets remixed into a lifestyle scene, and returns as a cutout in one call. The setting composes with the reference features cleanly.