---
title: Upscaling images with Wonder 3.5 — Topaz Labs Wonder 3.5 | Runware Docs
url: https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/upscaling-images
description: "How to upscale images with Topaz Wonder 3.5: the request shape, choosing an upscale factor, the input and output size limits, and what generative upscaling recovers."
---
Enlarging an image the ordinary way just resamples the pixels you already have. Push a small photo to four times its size in an editor and you get a **bigger version of the same blur**, because there is no more real detail to show. Wonder 3.5 takes the other route: it **generates the detail a plain resize cannot**, rebuilding fabric weave, skin texture, foliage, and clean edges as it scales the image up.

![A tan pebbled-leather tote handbag on a grey studio background, soft and low resolution](https://runware.ai/docs/assets/source-handbag.CAdoSAtX_1SPU2D.jpg)

*A 512 px product thumbnail rebuilt at four times the size. Drag to compare.*

Both frames sit at the same size on the page, so the difference is what each one actually holds. Drag the handle onto the leather and the source **runs out of detail past a certain zoom**, while the upscaled frame keeps resolving into grain and stitching. A 100% crop of the clasp makes it plain:

![A soft, blocky close-up crop of the handbag clasp and top-stitching](https://runware.ai/docs/assets/crop-source-handbag.BnUCsajh_294OHD.jpg)

*Source · 100% crop*

![The same crop from the upscaled image, with sharp individual stitches and leather grain](https://runware.ai/docs/assets/crop-output-handbag.B7t4EIbo_HwoeW.jpg)

*Wonder 3.5 · 100% crop*

The row of top-stitching that was a grey smear in the source comes back as **separate stitches**, and the pebbled grain reappears across the leather. Wonder did not sharpen those details, it **reconstructed them**, which is why the result reads as a genuinely larger photo rather than an enlarged thumbnail.

### [The request](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/upscaling-images#the-request)

Upscaling is one image in and one image out, and it runs **synchronously** like any image task: the response carries the finished `imageURL` directly, no polling. Put the source in `inputs.image` as a URL, a UUID from an earlier task, or a data URI, name the `model`, and set how far to scale with `upscaleFactor`.

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: 'topazlabs:wonder@3.5',
  upscaleFactor: 4,
  inputs: {
    image: 'https://im.runware.ai/image/os/a14d18/ws/2/ii/1a2b3c4d-5e6f-4708-9a1b-2c3d4e5f6071.jpg'
  }
})
```

```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": "topazlabs:wonder@3.5",
            "upscaleFactor": 4,
            "inputs": {
                "image": "https://im.runware.ai/image/os/a14d18/ws/2/ii/1a2b3c4d-5e6f-4708-9a1b-2c3d4e5f6071.jpg"
            }
        })

asyncio.run(main())
```

```bash
curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "upscale",
      "taskUUID": "b7c8d9e0-1f2a-4b3c-9d4e-5f6a7b8c9d0e",
      "model": "topazlabs:wonder@3.5",
      "upscaleFactor": 4,
      "inputs": {
        "image": "https://im.runware.ai/image/os/a14d18/ws/2/ii/1a2b3c4d-5e6f-4708-9a1b-2c3d4e5f6071.jpg"
      }
    }
  ]'
```

```bash
runware run topazlabs:wonder@3.5 \
  upscaleFactor=4 \
  inputs.image=https://im.runware.ai/image/os/a14d18/ws/2/ii/1a2b3c4d-5e6f-4708-9a1b-2c3d4e5f6071.jpg
```

```json
{
  "taskType": "upscale",
  "taskUUID": "b7c8d9e0-1f2a-4b3c-9d4e-5f6a7b8c9d0e",
  "model": "topazlabs:wonder@3.5",
  "upscaleFactor": 4,
  "inputs": {
    "image": "https://im.runware.ai/image/os/a14d18/ws/2/ii/1a2b3c4d-5e6f-4708-9a1b-2c3d4e5f6071.jpg"
  }
}
```

Response

```json
[
  {
    "taskType": "upscale",
    "taskUUID": "b7c8d9e0-1f2a-4b3c-9d4e-5f6a7b8c9d0e",
    "imageUUID": "8e9f0a1b-2c3d-4e5f-9a6b-7c8d9e0f1a2b",
    "imageURL": "https://im.runware.ai/image/os/a14d18/ws/2/ii/8e9f0a1b-2c3d-4e5f-9a6b-7c8d9e0f1a2b.jpg"
  }
]
```

- `inputs.image` is the only required input. It takes a URL, a UUID from a previous generation, or a base64 data URI.
- `upscaleFactor` is the scale multiplier, from 2 to 6, and defaults to 2.
- `settings.enhancementStrength` controls **how much detail Wonder invents**, covered in [enhancement strength](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/enhancement-strength).
- `settings.grain` adds film grain to the result, covered in [adding film grain](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/film-grain).

### [Choosing the upscale factor](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/upscaling-images#choosing-the-upscale-factor)

`upscaleFactor` multiplies both the width and the height, so a factor of 4 turns a 512 × 512 source into a 2048 × 2048 image and a factor of 2 doubles each edge. The right value is set by **how far the source has to travel**: a 2× pass gently sharpens an image that is already a usable size, while a 4× or higher pass is what rescues a small thumbnail or readies it for print.

The coastline below is the same idea on a wide landscape frame, a soft 512 px source lifted to 2048 px across:

![A soft, low-resolution aerial photo of a turquoise Mediterranean bay and ochre cliffs](https://runware.ai/docs/assets/source-coast.B6xszxHv_Z2ltBVh.jpg)

*A small travel photo enlarged 4×, foliage and rock detail rebuilt as it scales.*

The ceiling is on the **output**, which cannot exceed 256 megapixels, so the factor you pick caps the input Wonder will accept. That works out to roughly 64 MP of input at 2× (around 8000 × 8000), about 16 MP at 4× (around 4000 × 4000), and about 7 MP at 6×. A source larger than the cap for the factor you chose is rejected rather than clipped.

> [!WARNING]
> The input limit moves with the factor. An 8000 × 8000 source is fine at 2× but too large at 4×, because 4× would push the output past 256 MP. If a big source is refused, either lower `upscaleFactor` or downscale the input before sending it.

### [What generative upscaling does, and does not](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/upscaling-images#what-generative-upscaling-does-and-does-not)

Wonder rebuilds detail by **synthesizing it**, so it makes an image look sharp and richly textured rather than producing a forensically exact enlargement. On a reasonable source the invented detail tracks what was really there, which is why the handbag stitching and the coastline foliage read as correct. On a badly degraded source it will still **confidently invent texture** that looks right but may not match the original subject.

That shapes what to feed it. Wonder lifts a soft or small image well, but it cannot restore detail that was fully destroyed, so enhance a photo while it still carries a usable signal rather than after it has been crushed. Faces and fine text are the least forgiving targets, and each has its own approach in [restoring photos](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/restoring-photos) and [text and graphics](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/text-and-graphics).

### [Tips](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/upscaling-images#tips)

1. **Match the factor to the source.** Use 2× to firm up an image that is already close to the size you need, and 4× or higher only when a small source has real distance to cover. A bigger factor is not automatically better.
    
2. **Feed it recoverable input.** Wonder rebuilds soft and moderately small images well, but it works from whatever signal survives. Upscale before quality is destroyed, not after.
    
3. **Mind the size ceiling.** The output tops out at 256 megapixels, so the input limit tightens as the factor grows. Check your source against the cap for the factor you plan to use.
    
4. **Upscale at the end.** Do your cropping and colour work first, then upscale as the final step so the added detail lands on the finished frame rather than getting resampled again downstream.
    
5. **Judge the result at 100%.** A page-width preview hides both the gains and the artefacts. Open the full image or a crop at native size to see what Wonder actually reconstructed.
    
6. **Reach for the other controls when you need them.** Dial the invented detail up or down with [enhancement strength](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/enhancement-strength), and restore an organic, photographic texture with [film grain](https://runware.ai/docs/models/topazlabs-wonder-3-5/guides/film-grain).