---
title: Precision editing — GPT-Image-2.5 Sunburst | Runware Docs
url: https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst/guides/precision-editing
description: "How to use GPT-Image-2.5 Sunburst for detailed and repeated edits: what the longer generation time buys, and when to reach for it instead of Flare."
---
### [Introduction](https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst/guides/precision-editing#introduction)

OpenAI ships two image models in the 2.5 family and puts them on opposite sides of one trade. **Flare is the fast one** and the default for most work. **Sunburst is the one that takes longer**, built for premium workflows that need tighter control across detailed and iterative edits.

Nothing about the request changes between them. The same parameters, the same reference images, the same instructions, one different model string. What changes is how much the model works out before it commits, which is why the case for Sunburst is always a frame with **a lot to keep track of**.

**Source**:

![A kitchen worktop lined with six glass storage jars of different sizes, each with a pale wooden lid, beside a wooden board, a folded cloth and a small potted herb](https://runware.ai/docs/assets/source-worktop.DRJYlLIj_Z233YRj.jpg)

**Edited**:

![The same worktop with the tallest jar's lid changed to matte black and the five other pale wooden lids unchanged](https://runware.ai/docs/assets/output-hero.DiUtyK--_Zch55X.jpg)

> **Prompt**: Change only the lid of the tallest jar to matte black. Preserve every other jar, its lid, its contents and its position, and preserve the board, the cloth, the herb pot, the worktop, the framing and the lighting exactly as they are.

Six jars, six lids, and only one of them is supposed to move. That is the shape of problem Sunburst is for.

This guide covers the request, what the extra time buys on a detailed frame, how the two models hold up across a chain of edits, and how to choose between them.

### [The request](https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst/guides/precision-editing#the-request)

Sunburst takes the same surface as Flare, so anything written for one runs on the other by swapping `model`.

**TypeScript**:

```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: 'openai:gpt-image@2.5-sunburst',
  positivePrompt: 'Change only the lid of the tallest jar to matte black. Preserve every other jar, its lid, its contents and its position, and preserve the board, the cloth, the herb pot, the worktop, the framing and the lighting exactly as they are.',
  inputs: {
    referenceImages: [
      'https://im.runware.ai/image/os/a14d18/ws/2/ii/4f7a2c9e-1b58-4d63-8a05-7e3c1f6b9d24.jpg'
    ]
  },
  width: 1536,
  height: 1024
})
```

**Python**:

```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": "openai:gpt-image@2.5-sunburst",
            "positivePrompt": "Change only the lid of the tallest jar to matte black. Preserve every other jar, its lid, its contents and its position, and preserve the board, the cloth, the herb pot, the worktop, the framing and the lighting exactly as they are.",
            "inputs": {
                "referenceImages": [
                    "https://im.runware.ai/image/os/a14d18/ws/2/ii/4f7a2c9e-1b58-4d63-8a05-7e3c1f6b9d24.jpg"
                ]
            },
            "width": 1536,
            "height": 1024
        })

asyncio.run(main())
```

**cURL**:

```bash
curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "imageInference",
      "taskUUID": "8d1f4b7c-3a95-4602-9e78-2c6b0d4f8a13",
      "model": "openai:gpt-image@2.5-sunburst",
      "positivePrompt": "Change only the lid of the tallest jar to matte black. Preserve every other jar, its lid, its contents and its position, and preserve the board, the cloth, the herb pot, the worktop, the framing and the lighting exactly as they are.",
      "inputs": {
        "referenceImages": [
          "https://im.runware.ai/image/os/a14d18/ws/2/ii/4f7a2c9e-1b58-4d63-8a05-7e3c1f6b9d24.jpg"
        ]
      },
      "width": 1536,
      "height": 1024
    }
  ]'
```

**CLI**:

```bash
runware run openai:gpt-image@2.5-sunburst \
  positivePrompt="Change only the lid of the tallest jar to matte black. Preserve every other jar, its lid, its contents and its position, and preserve the board, the cloth, the herb pot, the worktop, the framing and the lighting exactly as they are." \
  inputs.referenceImages.0=https://im.runware.ai/image/os/a14d18/ws/2/ii/4f7a2c9e-1b58-4d63-8a05-7e3c1f6b9d24.jpg \
  width=1536 \
  height=1024
```

**JSON**:

```json
{
  "taskType": "imageInference",
  "taskUUID": "8d1f4b7c-3a95-4602-9e78-2c6b0d4f8a13",
  "model": "openai:gpt-image@2.5-sunburst",
  "positivePrompt": "Change only the lid of the tallest jar to matte black. Preserve every other jar, its lid, its contents and its position, and preserve the board, the cloth, the herb pot, the worktop, the framing and the lighting exactly as they are.",
  "inputs": {
    "referenceImages": [
      "https://im.runware.ai/image/os/a14d18/ws/2/ii/4f7a2c9e-1b58-4d63-8a05-7e3c1f6b9d24.jpg"
    ]
  },
  "width": 1536,
  "height": 1024
}
```

The parameter surface is documented once on the [model reference](https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst), and the techniques behind the instruction above are the same ones the Flare guides cover: [writing the edit](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/editing-images), [chaining passes](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/iterative-editing) and [confining one with a mask](https://runware.ai/docs/models/openai-gpt-image-2-5-flare/guides/masked-editing). This guide is only about **when the slower model is the right one**.

### [A frame with a lot to protect](https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst/guides/precision-editing#a-frame-with-a-lot-to-protect)

The number of things an instruction has to preserve is the variable that decides this. One subject on a plain background gives a model very little to get wrong. A person to camera in a working office gives it a great deal, and **a face is the least forgiving thing in any frame**.

![A woman in a navy branded polo standing beside a standing desk in a bright open-plan office, a lanyard around her neck, an open laptop and a closed notebook on the desk, a whiteboard and two potted plants behind her](https://runware.ai/docs/assets/source-spokesperson.D2MGgmUj_1FTqrL.jpg)

*A face, a whiteboard, a badge and a printed bottle, none of them part of the edit*

The same instruction ran on both models, at the same size and from that same reference.

**Flare**:

![The same woman at the same desk with her polo changed to deep burgundy, her face and the whiteboard unchanged, and the printed line on the water bottle rebuilt as overlapping glyphs](https://runware.ai/docs/assets/output-flare-detail.DJvtjSp1_Z137kef.jpg)

**Sunburst**:

![The same woman at the same desk with her polo in deep burgundy, her face, the whiteboard and the printed line on the water bottle all matching the source](https://runware.ai/docs/assets/output-sunburst-detail.DR8hoJ7G_ZUjXhk.jpg)

> **Prompt**: Change only the navy polo shirt to a deep burgundy one. Preserve its collar, its fit and the way it sits on her shoulders. Keep her face, her hair, her hands, the lanyard, the laptop, the notebook, the whiteboard, the plants, the desk, the framing and the lighting exactly as they are.

Both models turned the polo burgundy, kept her face and her pose, and left the whiteboard, the plants and the wall text alone. The polo is the easy half of the job.

Drag the handle to the **water bottle on the desk**. Its printed line reads "A BRIGHTER WORK TOMORROW" in the source. Sunburst brings it back intact. Flare rebuilds the second line as overlapping glyphs, so a legible piece of the frame that no instruction mentioned came back damaged. Numerically the two renders sit within a few percent of each other across the whole frame, which is the trap: **the difference that matters is small and legible**, and an eyeball comparison of the two images at a glance will miss it.

### [Across a chain](https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst/guides/precision-editing#across-a-chain)

The second case is repetition. Every pass in a chain re-renders the whole frame, so anything a model gives away per pass is paid three or four times over by the end. Both models ran the same three instructions in the same order from the same source.

![A fitness studio reception counter with folded towels and a potted plant, and a large printed weekly class schedule board on the wall behind it](https://runware.ai/docs/assets/source-studio.Bwp7L6rn_14Wd2q.jpg)

*A printed schedule nobody is going to mention in any of the three instructions*

**Flare, three passes**:

![The studio reception after three chained edits on Flare, with a teal mat, a sand-coloured wall and a steel water bottle on the counter](https://runware.ai/docs/assets/output-flare-pass-3.C9dZojpW_ZxCAmB.jpg)

**Sunburst, three passes**:

![The studio reception after the same three chained edits on Sunburst, with a teal mat, a sand-coloured wall and a steel water bottle on the counter](https://runware.ai/docs/assets/output-sunburst-pass-3.DaRjmLem_Z3EqXA.jpg)

> **Prompt**: Add a stainless steel water bottle standing upright on the bench beside the folded towel. Keep the teal mat, the dumbbells, the foam roller, the towel, the bench, the sand wall, the floor, the framing and the lighting unchanged.

None of the three instructions mentions the schedule board, so every line of type on it should survive all three rounds. Drag the handle across it and check.

**Both models held it.** Every row comes back correct on both sides, times and class names intact, after three passes that repainted the wall, recoloured the mat and added an object. The board is the sensitive instrument here, because legible type is where the previous section caught a difference, and on repetition it caught nothing.

That is worth knowing before you pay for the slower model. **Chains are not where these two separate.** The difference we could measure showed up on a single detailed edit, not on the number of times you edit.

> [!NOTE]
> Run this test on your own content before you commit to a model. Three passes on one representative frame costs six renders and answers the question for your subject matter, which is worth more than any general claim about which model is better.

### [Choosing between them](https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst/guides/precision-editing#choosing-between-them)

The trade is time against control, and it resolves differently depending on where the render sits in your pipeline.

**Reach for Flare** when the loop matters more than the frame. Exploration, high-volume generation, anything a user is waiting on, and any edit where one clearly-named thing changes on a simple background. Its speed is a product feature when somebody is sitting in front of it.

**Reach for Sunburst** when the frame matters more than the loop. A busy composition with many elements to preserve, a final asset going onto a product page or into print, and any job where a small unrequested change means a re-shoot rather than a re-render. Note what is missing from that list: **length of chain is not a reason on its own**, since three passes did not separate the two above.

The pattern that suits most teams is **both, at different stages**. Explore on Flare because iteration is where the calls are, then run the settled instruction once on Sunburst for the asset that ships. The request only differs by the model string, so switching costs a variable.

> [!WARNING]
> Sunburst is **not a quality level**, and it does not replace one. `settings.quality` still applies, and the two dials do different jobs: the level decides how much detail gets resolved, the model decides how carefully the rest of the frame is held while that happens. A busy edit at `low` on Sunburst is still a low-detail render.

### [Tips](https://runware.ai/docs/models/openai-gpt-image-2-5-sunburst/guides/precision-editing#tips)

1. **Swap the model string, keep everything else.** Anything written against Flare runs on Sunburst unchanged, which makes an A/B on your own content cheap.
    
2. **Count what should not have changed.** The requested change is the easy half. Audit the untouched half.
    
3. **Judge a chain against its source.** Drift is invisible between consecutive passes and would be obvious end to end, though on the test above three passes produced none on either model.
    
4. **Let the element count decide.** One subject on a plain background rarely justifies the wait. A frame with eight things in it often does.
    
5. **Explore on Flare, ship on Sunburst.** Iteration is where the volume is, and the final render is the only one that has to survive scrutiny.
    
6. **Set the quality level either way.** The model and the level are separate decisions, and Sunburst does not imply a high one.