# FLUX.1 [dev] with Controlnets and Loras · Differential Diffusion API

> Editing di immagini FLUX.1 [dev] guidato da una mappa delle modifiche che determina l'intensità dell'alterazione di ogni area

Trasforma un'immagine area per area usando una mappa delle modifiche per controllare quanto viene modificata ciascuna zona. Richiede `prompt`, `image_url` e `change_map_image_url`. Accetta anche LoRA, ControlNet, IP-Adapter e un'immagine di riferimento. `num_inference_steps` varia da 1 a 50 e `num_images` arriva a 10, con output png o jpeg.

- Model id: `flux-general/differential-diffusion`
- Made by: Black Forest Labs
- Category: Image Editing
- Output: image
- Estimated price per run: $0.138 / image (cheapest run $0.138 (138 API credits))
- Run: `POST https://api.doitong.com/v1/run/flux-general/differential-diffusion`
- Quote: `POST https://api.doitong.com/v1/quote/flux-general/differential-diffusion`
- Docs page: https://doitong.com/it/developers/models/flux-general/differential-diffusion

## Pricing

Price: **$0.138 / image**. Estimated from the typical cost of one run, per output (`num_images`). The quote is exactly what the run charges.

The full example input below costs $0.138 = 138 API credits (1 image × 138 API credits).

Prices are the upstream price in USD, paid from the API balance in API credits (1000 API credits = 1 USD). `POST https://api.doitong.com/v1/quote/flux-general/differential-diffusion` with the same JSON body returns the exact price for that input; the quote is exactly what a run charges. Invalid input is never charged and failed or canceled requests are refunded automatically.

## Input parameters

Send either the canonical name or the native field name (not both). Canonical names are the same across models.

| Parameter | Canonical name | Type | Required | Default | Allowed values / range | Description |
|---|---|---|---|---|---|---|
| `prompt` |  | string | yes |  |  | Prompt che guida la generazione di immagini. |
| `image_size` |  | object {width, height} \| enum (string) | no |  | `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | Dimensioni dell'immagine generata. |
| `num_inference_steps` |  | integer | no | `28` | 1 – 50 | Numero di passaggi di inferenza da eseguire. |
| `seed` |  | integer \| null | no |  |  | Seed per immagini riproducibili: prompt e seed identici producono un'immagine identica quando la versione del modello non cambia. |
| `loras` |  | array of object {path, scale} | no | `[]` |  | LoRA il cui effetto combinato produce l'immagine generata, senza limiti al numero fornito. |
| `loras[].path` |  | string | yes |  |  | Posizione dei pesi LoRA, specificata come URL o percorso. |
| `loras[].scale` |  | object \| number | no | `1` |  | Scala applicata ai pesi LoRA prima della fusione nel modello di base. Fornisci un dizionario nel formato {"layer_name":layer_scale} per impostare le scale dei singoli livelli; i livelli non specificati usano 1.0. |
| `control_loras` |  | array of object {path, scale, control_image_url, preprocess} | no | `[]` |  | LoRA delle immagini di controllo unite in una configurazione combinata per generare l'immagine finale; il numero fornito non è limitato. |
| `control_loras[].path` |  | string | yes |  |  | Posizione dei pesi LoRA, specificata come URL o percorso. |
| `control_loras[].scale` |  | object \| number | no | `1` |  | Scala applicata ai pesi LoRA prima della fusione nel modello di base. Fornisci un dizionario nel formato {"layer_name":layer_scale} per impostare le scale dei singoli livelli; i livelli non specificati usano 1.0. |
| `control_loras[].control_image_url` |  | string (image URL) | yes |  |  | URL dell'immagine che fornisce l'immagine di controllo. |
| `control_loras[].preprocess` |  | enum (string) | no | `None` | `canny`, `depth`, `None` | Metodo di preelaborazione applicato all'immagine fornita. |
| `controlnets` |  | array of object {path, config_url, variant, control_image_url, mask_image_url, mask_threshold, conditioning_scale, start_percentage, end_percentage} | no | `[]` |  | Configurazione ControlNet per la generazione dell'immagine, attualmente limitata a un singolo ControlNet. |
| `controlnets[].path` |  | string | yes |  |  | Posizione dei pesi ControlNet, specificata come URL o percorso. |
| `controlnets[].config_url` |  | string \| null | no |  |  | URL facoltativo che punta al file config.json di ControlNet. |
| `controlnets[].variant` |  | string \| null | no |  |  | Variante facoltativa da usare con una chiave di repository Hugging Face. |
| `controlnets[].control_image_url` |  | string (image URL) | yes |  |  | URL dell'immagine che fornisce l'immagine di controllo. |
| `controlnets[].mask_image_url` |  | string (image URL) | no |  |  | URL della maschera associata all'immagine di controllo. |
| `controlnets[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Valore di soglia della maschera. |
| `controlnets[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Scala applicata ai pesi ControlNet prima della loro fusione nel modello di base. |
| `controlnets[].start_percentage` |  | number | no | `0` | 0 – 1 | Percentuale dei timestep totali alla quale ControlNet inizia a influenzare la generazione dell'immagine. |
| `controlnets[].end_percentage` |  | number | no | `1` | 0 – 1 | Percentuale dei timestep totali alla quale ControlNet smette di influenzare la generazione dell'immagine. |
| `controlnet_unions` |  | array of object {path, config_url, variant, controls} | no | `[]` |  | Configurazione dell'unione ControlNet per la generazione dell'immagine, soggetta all'attuale limite di un singolo ControlNet. |
| `controlnet_unions[].path` |  | string | yes |  |  | Posizione dei pesi ControlNet, specificata come URL o percorso. |
| `controlnet_unions[].config_url` |  | string \| null | no |  |  | URL facoltativo che punta al file config.json di ControlNet. |
| `controlnet_unions[].variant` |  | string \| null | no |  |  | Variante facoltativa da usare con una chiave di repository Hugging Face. |
| `controlnet_unions[].controls` |  | array of object {control_image_url, mask_image_url, control_mode, conditioning_scale, mask_threshold, start_percentage, end_percentage} | yes |  |  | Immagini di controllo e modalità associate fornite a ControlNet. |
| `controlnet_unions[].controls[].control_image_url` |  | string (image URL) | yes |  |  | URL dell'immagine che fornisce l'immagine di controllo. |
| `controlnet_unions[].controls[].mask_image_url` |  | string (image URL) | no |  |  | URL della maschera associata all'immagine di controllo. |
| `controlnet_unions[].controls[].control_mode` |  | enum (string) | yes |  | `canny`, `tile`, `depth`, `blur`, `pose`, `gray`, `low-quality` | Modalità di controllo usata da Flux Controlnet Union. Opzioni: canny guida la generazione con i bordi; tile la guida con le piastrelle; depth la guida con una mappa di profondità in scala di grigi; blur sfoca l'immagine; pose guida la generazione con la posa dell'immagine; gray rende l'immagine in scala di grigi; low-quality produce una versione di bassa qualità dell'immagine. |
| `controlnet_unions[].controls[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Scala applicata ai pesi ControlNet prima della loro fusione nel modello di base. |
| `controlnet_unions[].controls[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Valore di soglia della maschera. |
| `controlnet_unions[].controls[].start_percentage` |  | number | no | `0` | 0 – 1 | Percentuale dei timestep totali alla quale ControlNet inizia a influenzare la generazione dell'immagine. |
| `controlnet_unions[].controls[].end_percentage` |  | number | no | `1` | 0 – 1 | Percentuale dei timestep totali alla quale ControlNet smette di influenzare la generazione dell'immagine. |
| `ip_adapters` |  | array of object {path, subfolder, weight_name, image_encoder_path, image_encoder_subfolder, image_encoder_weight_name, image_url, mask_image_url, mask_threshold, scale} | no | `[]` |  | IP-Adapter applicato durante la generazione dell'immagine. |
| `ip_adapters[].path` |  | string | yes |  |  | Posizione di IP-Adapter su Hugging Face. |
| `ip_adapters[].subfolder` |  | string \| null | no |  |  | Sottocartella contenente i pesi ip_adapter. |
| `ip_adapters[].weight_name` |  | string \| null | no |  |  | Nome file Safetensors dei pesi di IP-Adapter. |
| `ip_adapters[].image_encoder_path` |  | string | yes |  |  | Posizione dell'encoder di immagini di IP-Adapter, ad esempio 'openai/clip-vit-large-patch14'. |
| `ip_adapters[].image_encoder_subfolder` |  | string \| null | no |  |  | Sottocartella contenente i pesi dell'encoder di immagini. |
| `ip_adapters[].image_encoder_weight_name` |  | string \| null | no |  |  | Nome dell'encoder di immagini. |
| `ip_adapters[].image_url` |  | string (image URL) | yes |  |  | URL dell'immagine di condizionamento fornita a IP-Adapter. |
| `ip_adapters[].mask_image_url` |  | string (image URL) \| null | no |  |  | URL della maschera associata all'immagine di controllo. |
| `ip_adapters[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Valore di soglia della maschera. |
| `ip_adapters[].scale` |  | number | yes |  |  | Fattore di scala di IP-Adapter. |
| `easycontrols` |  | array of object {control_method_url, scale, image_url, image_control_type} | no | `[]` |  | Input EasyControl applicati durante la generazione dell'immagine. |
| `easycontrols[].control_method_url` |  | string | yes |  |  | URL dei pesi safetensor del metodo di controllo o identificatore supportato: `canny`, `depth`, `hedsketch`, `inpainting`, `pose`, `seg`, `subject`, `ghibli`. |
| `easycontrols[].scale` |  | number | no | `1` | 0 – 2 | Fattore di scala del metodo di controllo. |
| `easycontrols[].image_url` |  | string (image URL) | yes |  |  | URL dell'immagine che fornisce un input di controllo. |
| `easycontrols[].image_control_type` |  | enum (string) | yes |  | `subject`, `spatial` | Modalità di controllo dell'immagine; accetta `spatial` o `subject`. |
| `fill_image` |  | object {fill_image_url} \| null | no |  |  | Immagine di input che guida la generazione e può fornire contenuto per le regioni mascherate. |
| `fill_image.fill_image_url` |  | string (image URL) \| array of image URL | no | `[]` |  | URL delle immagini da riempire tramite prompting redux. |
| `guidance_scale` |  | number | no | `3.5` | 0 – 20 | Intensità di aderenza al prompt per la selezione dell'immagine, espressa come CFG (Classifier Free Guidance). |
| `real_cfg_scale` |  | number | no | `3.5` | 0 – 5 | Intensità di aderenza al prompt per la selezione dell'immagine, espressa come CFG (Classifier Free Guidance). |
| `use_real_cfg` |  | boolean | no | `false` |  | Opzione CFG classica, abilitata automaticamente con XLabs IP-Adapter v1. Il comportamento della guidance corrisponde a quello di modelli come SD1.5 e SDXL. |
| `use_cfg_zero` |  | boolean | no | `false` |  | Abilita il campionamento con inizializzazione CFG-zero, descritto in https://arxiv.org/abs/2503.18886. |
| `num_images` | `num_outputs` | integer | no | `1` | 1 – 10 | Imposta quante immagini generare; questa scelta è fissa su 1 quando l'output viene trasmesso in streaming. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Controllo di sicurezza, che restituisce immagini nere al posto di quelle segnalate come non sicure. Il valore true abilita il controllo; false lo disabilita solo per account autorizzati, mentre le richieste senza autorizzazione vengono comunque controllate. |
| `reference_image_url` |  | string (image URL) | no |  |  | URL dell'immagine usato per la guidance Reference-Only. |
| `reference_strength` |  | number | no | `0.65` | -3 – 3 | Influenza dell'immagine di riferimento durante la generazione reference_only; senza un'immagine di riferimento fornita, questa impostazione dell'intensità non ha effetto. |
| `reference_start` |  | number | no | `0` | 0 – 1 | Punto iniziale della guidance di riferimento, espresso come percentuale di tutti i timestep. |
| `reference_end` |  | number | no | `1` | 0 – 1 | Punto finale della guidance di riferimento, espresso come percentuale di tutti i timestep. |
| `base_shift` |  | number | no | `0.5` | 0.01 – 5 | Spostamento di base applicato ai timestep pianificati. |
| `max_shift` |  | number | no | `1.15` | 0.01 – 5 | Spostamento massimo applicato ai timestep pianificati. |
| `output_format` |  | enum (string) | no | `png` | `jpeg`, `png` | Formato del file dell'immagine risultante. |
| `use_beta_schedule` |  | boolean | no | `false` |  | Controlla se usare le sigma beta. |
| `sigma_schedule` |  | string \| null | no |  |  | Pianificazione delle sigma usata durante il denoising. |
| `scheduler` |  | enum (string) | no | `euler` | `euler`, `dpmpp_2m` | Scheduler usato durante il denoising. |
| `negative_prompt` |  | string | no | `` |  | Prompt negativo elaborato con NAG per impostazione predefinita, per scoraggiare le caratteristiche indesiderate specificate nelle immagini generate. |
| `nag_scale` |  | number | no | `3` | ≤ 10, > 1 | Evitamento del prompt negativo controllato dalla scala NAG: aumentandola, l'immagine generata sarà meno simile alla descrizione negativa. |
| `nag_tau` |  | number | no | `2.5` | > 0 | Impostazione tau di NAG per la normalizzazione dello stato nascosto; è consigliato lasciarla invariata. Aumentandola si indebolisce la normalizzazione e si rischiano deviazioni impreviste dall'immagine originale. |
| `nag_alpha` |  | number | no | `0.25` | ≤ 1, > 0 | Alpha NAG determina quanto il prompt positivo reindirizza la guidance normalizzata che combina i prompt positivo e negativo. Questa ponderazione finale dà maggiore influenza al prompt positivo con impostazioni più basse e riduce il reindirizzamento con impostazioni più alte. |
| `nag_end` |  | number | no | `0.25` | ≤ 1, > 0 | Cutoff NAG espresso come proporzione dei passaggi di generazione. I processori di attenzione originali di FLUX subentrano dopo che NAG è stato eseguito per quella proporzione iniziale. |
| `image_url` | `image` | string (image URL) | yes |  |  | URL dell'immagine iniziale. |
| `change_map_image_url` |  | string (image URL) | yes |  |  | URL che punta alla mappa delle modifiche. |
| `strength` |  | number | no | `0.85` | 0.01 – 1 | Intensità della diffusione differenziale, dalla conservazione dell'originale a 0.0 alla ricostruzione completa a 1.0. |

File parameters (`reference_image_url`, `image`, `change_map_image_url`) take a public `https://` URL, a `data:` URI up to 10 MB, or the `file_url` of an upload from `POST /files`.

## Example input

Required parameters only:

```json
{
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
  "image": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
  "change_map_image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
}
```

A fuller example:

```json
{
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
  "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
  "change_map_image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
}
```

## Run it

Set `DOITONG_API_KEY` to a key from https://doitong.com/developers/dashboard#keys. `?wait=20` returns the finished request in the same call when it is ready within 20 seconds; otherwise poll `GET /requests/{id}` (it also accepts `?wait=`), or pass `webhook_url`.

### curl

```bash
# Run the model; wait up to 20 s for the finished result in the same call
curl -X POST "https://api.doitong.com/v1/run/flux-general/differential-diffusion?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
    "change_map_image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
  }'

# Still "queued" or "running"? Poll with the id from the response:
curl "https://api.doitong.com/v1/requests/REQUEST_ID?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

### JavaScript

```javascript
const API = "https://api.doitong.com/v1";
const headers = {
  "Authorization": "Bearer " + process.env.DOITONG_API_KEY,
  "Content-Type": "application/json",
};

// Run the model; wait up to 20 s for the finished result in the same call
let res = await fetch(API + "/run/flux-general/differential-diffusion?wait=20", {
  method: "POST",
  headers,
  body: JSON.stringify({
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
    "change_map_image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
  }),
});
let request = await res.json();
if (!res.ok) throw new Error(request.error.code + ": " + request.error.message);

// Not finished yet: long-poll until it is
while (request.status === "queued" || request.status === "running") {
  res = await fetch(API + "/requests/" + request.id + "?wait=20", { headers });
  request = await res.json();
}
if (request.status !== "succeeded") throw new Error(JSON.stringify(request.error));
console.log(request.outputs.map((o) => o.url), request.cost.credits + " API credits ($" + request.cost.usd + ")");
```

### Python

```python
import os
import requests

API = "https://api.doitong.com/v1"
headers = {"Authorization": "Bearer " + os.environ["DOITONG_API_KEY"]}

payload = {
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
    "change_map_image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
}

# Run the model; wait up to 20 s for the finished result in the same call
r = requests.post(API + "/run/flux-general/differential-diffusion", params={"wait": 20}, json=payload, headers=headers)
request = r.json()
if not r.ok:
    raise RuntimeError(request["error"]["code"] + ": " + request["error"]["message"])

# Not finished yet: long-poll until it is
while request["status"] in ("queued", "running"):
    request = requests.get(API + "/requests/" + request["id"], params={"wait": 20}, headers=headers).json()
if request["status"] != "succeeded":
    raise RuntimeError(request["error"])
print([o["url"] for o in request["outputs"]], request["cost"]["credits"], "API credits", "$" + request["cost"]["usd"])
```

### MCP

The MCP server at `https://api.doitong.com/v1/mcp` exposes the tools `search_models`, `get_model`, `quote`, `run`, `get_request`, `cancel_request`, `list_requests`, `create_upload` and `get_account`. A `run` call for this model:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "run",
    "arguments": {
      "model_id": "flux-general/differential-diffusion",
      "input": {
        "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
        "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
        "change_map_image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
      },
      "wait_seconds": 20
    }
  }
}
```

## Response

Every call returns a request object. `status` is one of `queued`, `running`, `succeeded`, `failed`, `canceled`. `outputs` lists the generated files with URLs on our storage (kept forever, or 7 days with `?storage=temporary`; `storage` says which); `output` is the model's own result object with the same URLs.

```json
{
  "id": "req_8k2m4q7x1z9c3v5b6n0p2r4t",
  "object": "request",
  "model": "flux-general/differential-diffusion",
  "status": "succeeded",
  "created_at": "2026-10-20T12:00:00Z",
  "started_at": "2026-10-20T12:00:02Z",
  "completed_at": "2026-10-20T12:00:09Z",
  "queue_position": null,
  "cost": {
    "credits": 138,
    "usd": "0.138",
    "charged": 138,
    "refunded": 0
  },
  "input": {
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
    "change_map_image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
  },
  "output": {
    "images": [
      {
        "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
        "width": 1024,
        "height": 768,
        "content_type": "image/jpeg"
      }
    ],
    "timings": {},
    "seed": 42,
    "has_nsfw_concepts": [
      false
    ],
    "prompt": "string"
  },
  "outputs": [
    {
      "type": "image",
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_size": 1843200,
      "width": 1024,
      "height": 768,
      "stored": true
    }
  ],
  "error": null,
  "metrics": {
    "inference_seconds": 6.8
  },
  "urls": {
    "self": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t",
    "cancel": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/cancel"
  }
}
```

### Output fields (`output`)

| Field | Type | Description |
|---|---|---|
| `images` | array of object {url, width, height, content_type} | Informazioni sui file delle immagini generate. |
| `timings` | object |  |
| `seed` | integer | Seed della generazione di immagini, incluso il valore scelto casualmente se l'input non forniva un seed; altrimenti ripete il valore fornito. |
| `has_nsfw_concepts` | array of boolean | Indica se nelle immagini generate compaiono concetti NSFW. |
| `prompt` | string | Prompt usato durante la generazione di immagini. |

## Related models

- [FLUX.1 \[dev\] with Controlnets and Loras](https://doitong.com/developers/models/flux-general.md) (`flux-general`): $0.30 / image
- [FLUX.1 \[dev\] with Controlnets and Loras · Image to Image](https://doitong.com/developers/models/flux-general/image-to-image.md) (`flux-general/image-to-image`): $0.15 / image
- [FLUX.1 \[dev\] with Controlnets and Loras · Inpainting](https://doitong.com/developers/models/flux-general/inpainting.md) (`flux-general/inpainting`): $0.192 / image
- [FLUX.1 \[dev\] with Controlnets and Loras · Rf Inversion](https://doitong.com/developers/models/flux-general/rf-inversion.md) (`flux-general/rf-inversion`): $0.025 / image
- [FLUX.1 Kontext \[pro\]](https://doitong.com/developers/models/flux-pro/kontext.md) (`flux-pro/kontext`): $0.04 / image
- [GPT Image 2.5 Edit](https://doitong.com/developers/models/openai/gpt-image-2.5/flare/edit.md) (`openai/gpt-image-2.5/flare/edit`): from $0.12 / image
- [Nano Banana 2 Edit](https://doitong.com/developers/models/nano-banana-2/edit.md) (`nano-banana-2/edit`): from $0.06 / image
- [Nano Banana Pro Edit](https://doitong.com/developers/models/nano-banana-pro/edit.md) (`nano-banana-pro/edit`): from $0.15 / image

## Links

- HTML page: https://doitong.com/developers/models/flux-general/differential-diffusion
- All models and guides for AI agents: https://doitong.com/developers/llms.txt
- OpenAPI 3.1 with this model's typed request body: https://doitong.com/developers/openapi.json?model=flux-general/differential-diffusion
- Errors: https://doitong.com/developers/docs/errors
- Model details as JSON: https://api.doitong.com/v1/models/flux-general/differential-diffusion