---
title: Extending images with FLUX Outpainting — FLUX Outpainting | Runware Docs
url: https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images
description: How to use FLUX Outpainting, a prompt-less image-extension model from Black Forest Labs. Covers the request shape, when prompt-less extension is the right tool, three practical extension patterns, and sizing limits.
---
### [Introduction](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#introduction)

FLUX Outpainting is a Black Forest Labs model dedicated to one job: **extending an image beyond its original borders**. It's a single call, takes no text prompt, and produces a result tuned for **visual continuity** with the source. Lighting, texture, depth, and composition carry through automatically. You don't tell the model what should appear in the new regions, you tell it how much to extend in each direction.

![A 1024 × 1024 coastal scene extended 512 px on each side → 2048 × 1024 banner. Hover to reveal the seamless result.](https://runware.ai/docs/assets/output-hero-banner.Bp87FH8r_Z2jika2.jpg)

*A 1024 × 1024 coastal scene extended 512 px on each side → 2048 × 1024 banner. Hover to reveal the seamless result.*

This guide covers when this model is the right call (vs the prompt-based outpaint workflows documented in the [image outpainting guide](https://runware.ai/docs/guides/image-outpainting) ), the request shape, practical extension patterns, and the sizing rules to stay inside.

### [Request shape](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#request-shape)

A FLUX Outpainting request is small. You pass the source image, a pixel extension per side, and an optional `autoCrop` flag for edge cases:

**Request**:

```json
[
  {
    "taskType": "imageInference",
    "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "model": "bfl:flux@outpainting",
    "inputs": {
      "image": "https://example.com/source.jpg"
    },
    "outpaint": {
      "top": 0,
      "right": 384,
      "bottom": 0,
      "left": 384
    },
    "settings": {
      "autoCrop": true
    }
  }
]
```

**Response**:

```json
{
  "data": [
    {
      "taskType": "imageInference",
      "taskUUID": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "imageUUID": "f1e2d3c4-b5a6-7890-1234-567890abcdef",
      "imageURL": "https://im.runware.ai/image/ws/2/ii/f1e2d3c4-b5a6-7890-1234-567890abcdef.jpg"
    }
  ]
}
```

The three things that matter:

- `inputs.image` is the source. Accepts a public URL, a base64 string, a data URI, or a UUID (typically the UUID of a previous generation, or one returned from the [Image Upload API](https://runware.ai/docs/platform/image-upload) ).
- `outpaint` is the extension in pixels per side. Every side defaults to `0`. Set the sides you want to grow. Asymmetric values are fine (extend the left more than the right, for example).
- `settings.autoCrop` controls what happens when an extension would push the resulting canvas past the model's size limits. With `autoCrop: true`, the request still succeeds by cropping the result. With it off, the request fails. Use `true` when you want a result no matter what.

There's no `positivePrompt`, no `negativePrompt`, no `strength`, no scheduler. The only knob is the extension geometry.

### [When prompt-less wins](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#when-prompt-less-wins)

The generic [outpainting workflow](https://runware.ai/docs/guides/image-outpainting) uses a prompt to steer what the model paints into the new regions. That's the right tool when you want to **add something specific** that isn't already visible at the source's edges. FLUX Outpainting goes the other direction: it commits to **continuing whatever's already there** and asks you nothing about what it should be.

Reach for prompt-less when:

- The source is a **natural scene or texture** (landscapes, interiors, fabrics, food, skies) where "more of the same" is the goal.
- You're doing **aspect-ratio changes** for production reformatting: a landscape going to widescreen, a portrait going to vertical, a square going to a social-banner shape.
- You want a **predictable result fast**, without iterating on prompt language.
- The edges of the source already contain enough visual information for the model to continue (no hard cutoffs or isolated objects at the boundary).

Reach for the prompted outpaint flow when:

- You want the new regions to introduce **new elements** that don't appear at the source edges (a mountain range above a portrait, a beach beside a building).
- You want **stylistic redirection**, such as turning a daylight scene into a night extension.

A useful mental model: **prompted outpainting paints**, while **FLUX Outpainting extends**.

### [Extension patterns](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#extension-patterns)

Three patterns cover the bulk of real-world use. Each one uses the same model and the same parameter shape, only the `outpaint` values change.

#### [Widening a landscape](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#widening-a-landscape)

Pure horizontal extension. Useful for turning a natural landscape into a widescreen banner without re-shooting. The source needs enough information at the left and right edges that the model can continue the scene. For forests, mountains, fields, coastlines, and skies, this almost always holds.

![1216 × 896 → 1984 × 896. Extended 384 px left and right.](https://runware.ai/docs/assets/output-landscape-banner.bl6KtSdU_Z1Po2pw.jpg)

*1216 × 896 → 1984 × 896. Extended 384 px left and right.*

The same source can be extended differently to produce different widescreen ratios (extend by 128 per side to land at 1472 × 896, or by 416 per side to land at 2048 × 896). The model's job stays the same.

#### [Adding environment around a subject](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#adding-environment-around-a-subject)

Symmetric extension in all four directions. Useful when the source is a tight portrait or product shot and you want more breathing room without re-framing the subject. The model fills in walls, floors, sky, or surface continuation around the existing composition.

![896 × 1216 → 1152 × 1472. Extended 128 px on all four sides.](https://runware.ai/docs/assets/output-portrait-environment.SHW2gR9w_1GkObL.jpg)

*896 × 1216 → 1152 × 1472. Extended 128 px on all four sides.*

The subject's pose, framing, and identity are untouched. The model only fills the new outer ring, and the original pixels stay where they were.

#### [Reshaping for a different format](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#reshaping-for-a-different-format)

Asymmetric extension. Useful when you need to convert a source into a different aspect ratio for a specific surface (a social banner, a web hero, a print spread) without losing the original framing of the subject.

![1024 × 1024 → 2048 × 1024. Extended 512 px left and right.](https://runware.ai/docs/assets/output-product-banner.DaothwxZ_Z1XUsTt.jpg)

*1024 × 1024 → 2048 × 1024. Extended 512 px left and right.*

The original arrangement sits centered in the new canvas, and the surface continues in either direction. For a vertical reshape (square to portrait), the same pattern works with `top` and `bottom` values instead.

### [Sizing and limits](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#sizing-and-limits)

Two hard rules to stay inside.

**Output dimensions are derived from the source plus the extensions.** `output_width = source_width + outpaint.left + outpaint.right`, and similarly for height. You don't pass `width` and `height` directly on this model. The request computes them from your source and your extension values.

**The output ceiling is 4 megapixels, and neither side may exceed 2048 pixels.** The model produces results up to 4 MP total area, with a hard maximum of 2048 on each axis. Valid shapes include 2048 × 1024 (2 MP), 2048 × 2048 (4 MP), or 1536 × 1536 (2.4 MP). Exceeding either limit returns an error. If you need a 4K output, generate at or near these ceilings and upscale downstream.

Where `autoCrop` comes in: if the extension you request would yield a canvas above the limits, the default behavior is a 422 error. With `autoCrop: true`, the model crops the result to fit instead of failing.

Say you have a 1536 × 1024 source and request 512 px on all four sides. That would produce a 2560 × 2048 output, which exceeds the 2048 per-side limit. Adding `autoCrop` lets the request succeed:

```json
{
  "inputs": { "image": "https://..." },
  "outpaint": { "top": 512, "right": 512, "bottom": 512, "left": 512 },
  "settings": { "autoCrop": true }
}
```

The output is cropped to fit within 2048 × 2048, so the effective extension on the overflowing axis is reduced. For production pipelines where you'd rather get *something* back than a 400, set `autoCrop: true` and accept the potential size reduction.

> [!NOTE]
> The model also handles modestly small expansions well, but the gain becomes hard to see below ~64 pixels per side. If a request only asks for a few-pixel extension, prefer cropping the source or using a different reframing tool. The model is built for meaningful extensions, not micro-adjustments.

### [Tips](https://runware.ai/docs/models/bfl-flux-outpainting/guides/extending-images#tips)

1. **Extend the side that has the most information.** If the right edge of your source shows clear continuation cues (a path, a horizon line, a wall) and the left edge is mostly empty space, the model will produce a cleaner extension on the right. Asymmetric `outpaint` values are an explicit lever for this.
    
2. **Plan output dimensions before you set the deltas.** Decide the target canvas first ("this needs to become 2048 × 1024 for the hero"), subtract the source dimensions, and split the difference across the sides you want to grow. Working backward is faster than tweaking deltas until the math lines up.
    
3. **For aspect-ratio conversions, keep one axis fixed.** If the source is good landscape and you want widescreen, extend left and right only and leave top and bottom at `0`. Mixing extensions on both axes increases the model's workload and the chance of visible seams.
    
4. **Prompt-less means "no creative direction".** If the result feels generic or doesn't match the source's mood, that's expected. The model has no way to know the mood you wanted. Switch to the prompted outpaint workflow when the new regions need to do more than continue what's there.
    
5. **Set `autoCrop: true` in production pipelines.** Failing soft on oversized requests beats failing hard. The result may be smaller than naively expected, but a smaller success is more useful than a 400 in an automated system.
    
6. **Stay at or under 2 MP for the most consistent results.** The 4 MP ceiling is the hard limit, but quality variance grows as you approach it. For predictable production output, target outputs in the 1-2 MP range and upscale only when needed.