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

> FLUX.1 [dev] בילד־עדיטירונג געטריבן דורך אַ ענדערונג־מאַפּע וואָס באַשטימט ווי שטאַרק יעדער געגנט ווערט געענדערט

טראַנספֿאָרמירט אַ מקורבילד געגנט פֿאַר געגנט, מיט אַ ענדערונג־מאַפּע־בילד צו קאָנטראָלירן וויפֿל יעדער שטח ווערט מאָדיפיצירט. עס דאַרף `prompt`, `image_url` און `change_map_image_url`. עס נעמט אויך LoRAs, ControlNets, IP-Adapters און אַ רעפֿערענץ־בילד. `num_inference_steps` לויפֿט פֿון 1 ביז 50 און `num_images` ביז 10, מיט png אָדער 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/yi/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 |  |  | פּראָמפּט וואָס פירט בילד־גענערירונג. |
| `image_size` |  | object {width, height} \| enum (string) | no |  | `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | דימענסיעס פֿונעם גענערירטן בילד. |
| `num_inference_steps` |  | integer | no | `28` | 1 – 50 | צאָל אינפֿערענץ־סטעפּס צו לויפֿן. |
| `seed` |  | integer \| null | no |  |  | סיד פֿאַר רעפּראָדוצירבאַרע בילדער: אַן אידענטישער פּראָמפּט און סיד שאַפֿן אַן אידענטיש בילד ווען די מאָדעל־ווערסיע איז אומגעענדערט. |
| `loras` |  | array of object {path, scale} | no | `[]` |  | LoRA־ס וועמענס צוזאַמענגעפאסטער ווירקונג פּראָדוצירט דאָס גענערירטע בילד, אָן אַ לימיט פֿאַר זייער צאָל. |
| `loras[].path` |  | string | yes |  |  | אָרט פֿון די LoRA־וואָגען, ספּעציפֿיצירט ווי אַ URL אָדער פּאַט. |
| `loras[].scale` |  | object \| number | no | `1` |  | סקיילינג וואָס ווערט אָנגעווענדט אויף LoRA־ווייטס איידער זיי ווערן צונויפֿגעמישט מיטן באַזע־מאָדעל. צושטעלן אַ דיקשאַנערי פֿון דער פֿאָרעם {"layer_name":layer_scale} צו באַשטימען יחיד־לייַער־סקיילס; נישט ספּעציפיצירטע לייַערס נוצן 1.0. |
| `control_loras` |  | array of object {path, scale, control_image_url, preprocess} | no | `[]` |  | קאָנטראָל־בילד־LoRA־ס וואָס ווערן צונויפֿגעמישט אין אַ קאָמבינירטער קאָנפיגוראַציע פֿאַר גענערירן דאָס לעצטע בילד; די צוגעשטעלטע צאָל איז נישט באַגרענעצט. |
| `control_loras[].path` |  | string | yes |  |  | אָרט פֿון די LoRA־וואָגען, ספּעציפֿיצירט ווי אַ URL אָדער פּאַט. |
| `control_loras[].scale` |  | object \| number | no | `1` |  | סקיילינג וואָס ווערט אָנגעווענדט אויף LoRA־ווייטס איידער זיי ווערן צונויפֿגעמישט מיטן באַזע־מאָדעל. צושטעלן אַ דיקשאַנערי פֿון דער פֿאָרעם {"layer_name":layer_scale} צו באַשטימען יחיד־לייַער־סקיילס; נישט ספּעציפיצירטע לייַערס נוצן 1.0. |
| `control_loras[].control_image_url` |  | string (image URL) | yes |  |  | בילד־URL וואָס צושטעלט דאָס קאָנטראָל־בילד. |
| `control_loras[].preprocess` |  | enum (string) | no | `None` | `canny`, `depth`, `None` | פּרעפּראָסעסינג־מעטאָד וואָס ווערט אָנגעווענדט אויף דעם צוגעשטעלטן בילד. |
| `controlnets` |  | array of object {path, config_url, variant, control_image_url, mask_image_url, mask_threshold, conditioning_scale, start_percentage, end_percentage} | no | `[]` |  | ControlNet־קאָנפיגוראַציע פֿאַר בילד־גענערירונג, דערווײַל באַגרענעצט צו איין ControlNet. |
| `controlnets[].path` |  | string | yes |  |  | אָרט פֿון די ControlNet־ווייטס, ספּעציפיצירט ווי אַ URL אָדער פּאַט. |
| `controlnets[].config_url` |  | string \| null | no |  |  | אָפּציאָנאַלער URL צו דער config.json־פֿײַל פֿון ControlNet. |
| `controlnets[].variant` |  | string \| null | no |  |  | אָפּציאָנאַלע וואַריאַנט פֿאַר נוצן מיט אַ Hugging Face־רעפּאַזאַטאָריע־קיי. |
| `controlnets[].control_image_url` |  | string (image URL) | yes |  |  | בילד־URL וואָס צושטעלט דאָס קאָנטראָל־בילד. |
| `controlnets[].mask_image_url` |  | string (image URL) | no |  |  | מאַסקע־URL וואָס געהערט צום קאָנטראָל־בילד. |
| `controlnets[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | מאַסקע־טהרעשאָלד־וואַלוע. |
| `controlnets[].conditioning_scale` |  | number | no | `1` | 0 – 2 | סקיילינג וואָס ווערט אָנגעווענדט אויף ControlNet־ווייטס איידער זיי ווערן צונויפֿגעמישט מיטן באַזע־מאָדעל. |
| `controlnets[].start_percentage` |  | number | no | `0` | 0 – 1 | פּראָצענט פֿון אַלע טימסטעפּס בײַ וועלכן ControlNet הייבט אָן צו ווירקן אויף בילד־גענערירונג. |
| `controlnets[].end_percentage` |  | number | no | `1` | 0 – 1 | פּראָצענט פֿון אַלע טימסטעפּס בײַ וועלכן ControlNet הערט אויף צו ווירקן אויף בילד־גענערירונג. |
| `controlnet_unions` |  | array of object {path, config_url, variant, controls} | no | `[]` |  | ControlNet union־קאָנפיגוראַציע פֿאַר בילד־גענערירונג, אונטער דער איצטיקער באַגרענעצונג צו איין ControlNet. |
| `controlnet_unions[].path` |  | string | yes |  |  | אָרט פֿון די ControlNet־ווייטס, ספּעציפיצירט ווי אַ URL אָדער פּאַט. |
| `controlnet_unions[].config_url` |  | string \| null | no |  |  | אָפּציאָנאַלער URL צו דער config.json־פֿײַל פֿון ControlNet. |
| `controlnet_unions[].variant` |  | string \| null | no |  |  | אָפּציאָנאַלע וואַריאַנט פֿאַר נוצן מיט אַ 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 |  |  | קאָנטראָל־בילדער און פֿאַרבונדענע מאָדעס וואָס ווערן צוגעשטעלט צו ControlNet. |
| `controlnet_unions[].controls[].control_image_url` |  | string (image URL) | yes |  |  | בילד־URL וואָס צושטעלט דאָס קאָנטראָל־בילד. |
| `controlnet_unions[].controls[].mask_image_url` |  | string (image URL) | no |  |  | מאַסקע־URL וואָס געהערט צום קאָנטראָל־בילד. |
| `controlnet_unions[].controls[].control_mode` |  | enum (string) | yes |  | `canny`, `tile`, `depth`, `blur`, `pose`, `gray`, `low-quality` | קאָנטראָל־מאָדע גענוצט דורך Flux Controlnet Union. אָפּציעס: canny פירט די גענערירונג מיט קאַנטן; tile מיט טיילס; depth מיט אַ גרייסקעל־טיפֿעניש־מאַפּע; blur פֿאַרוואַסערט דאָס בילד; pose פירט מיטן פּאָזע פֿון בילד; gray מאַכט דאָס בילד גרייסקעל; low-quality פּראָדוצירט אַ בילד מיט נידעריקער קוואַליטעט. |
| `controlnet_unions[].controls[].conditioning_scale` |  | number | no | `1` | 0 – 2 | סקיילינג וואָס ווערט אָנגעווענדט אויף ControlNet־ווייטס איידער זיי ווערן צונויפֿגעמישט מיטן באַזע־מאָדעל. |
| `controlnet_unions[].controls[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | מאַסקע־טהרעשאָלד־וואַלוע. |
| `controlnet_unions[].controls[].start_percentage` |  | number | no | `0` | 0 – 1 | פּראָצענט פֿון אַלע טימסטעפּס בײַ וועלכן ControlNet הייבט אָן צו ווירקן אויף בילד־גענערירונג. |
| `controlnet_unions[].controls[].end_percentage` |  | number | no | `1` | 0 – 1 | פּראָצענט פֿון אַלע טימסטעפּס בײַ וועלכן ControlNet הערט אויף צו ווירקן אויף בילד־גענערירונג. |
| `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 וואָס ווערט אָנגעווענדט בעת בילד־גענערירונג. |
| `ip_adapters[].path` |  | string | yes |  |  | אָרט פֿון IP-Adapter אויף Hugging Face. |
| `ip_adapters[].subfolder` |  | string \| null | no |  |  | סאַבפֿאָלדער מיט די ip_adapter־ווייטס. |
| `ip_adapters[].weight_name` |  | string \| null | no |  |  | Safetensors־פֿײַלנאָמען פֿאַר די ווייטס פֿון IP-Adapter. |
| `ip_adapters[].image_encoder_path` |  | string | yes |  |  | אָרט פֿון דעם בילד־ענקאָדער פֿאַר IP-Adapter, ווי 'openai/clip-vit-large-patch14'. |
| `ip_adapters[].image_encoder_subfolder` |  | string \| null | no |  |  | סאַבפֿאָלדער מיט ווייטס פֿאַר דעם בילד־ענקאָדער. |
| `ip_adapters[].image_encoder_weight_name` |  | string \| null | no |  |  | נאָמען פֿון דעם בילד־ענקאָדער. |
| `ip_adapters[].image_url` |  | string (image URL) | yes |  |  | קאַנדישאַנינג־בילד־URL וואָס ווערט צוגעשטעלט צו IP-Adapter. |
| `ip_adapters[].mask_image_url` |  | string (image URL) \| null | no |  |  | מאַסקע־URL וואָס געהערט צום קאָנטראָל־בילד. |
| `ip_adapters[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | מאַסקע־טהרעשאָלד־וואַלוע. |
| `ip_adapters[].scale` |  | number | yes |  |  | סקיילינג־פאַקטאָר פֿון IP-Adapter. |
| `easycontrols` |  | array of object {control_method_url, scale, image_url, image_control_type} | no | `[]` |  | EasyControl־אַרײַנגעבונגען וואָס ווערן אָנגעווענדט בעת בילד־גענערירונג. |
| `easycontrols[].control_method_url` |  | string | yes |  |  | Safetensor־ווייט־URL פֿון דער קאָנטראָל־מעטאָד, אָדער אַ געשטיצטער אידענטיפֿיער: `canny`, `depth`, `hedsketch`, `inpainting`, `pose`, `seg`, `subject`, `ghibli`. |
| `easycontrols[].scale` |  | number | no | `1` | 0 – 2 | סקיילינג־פאַקטאָר פֿון דער קאָנטראָל־מעטאָד. |
| `easycontrols[].image_url` |  | string (image URL) | yes |  |  | בילד־URL וואָס צושטעלט אַ קאָנטראָל־אַרײַנגעבונג. |
| `easycontrols[].image_control_type` |  | enum (string) | yes |  | `subject`, `spatial` | בילד־קאָנטראָל־מאָדע; נעמט אָן אָדער `spatial` אָדער `subject`. |
| `fill_image` |  | object {fill_image_url} \| null | no |  |  | אַרײַנגעגעבענער בילד וואָס פירט די גענערירונג און קען צושטעלן אינהאַלט פֿאַר געמאסקירטע געגנטן. |
| `fill_image.fill_image_url` |  | string (image URL) \| array of image URL | no | `[]` |  | בילד־URL־ס פֿאַר אָנפֿילן דורך redux prompting. |
| `guidance_scale` |  | number | no | `3.5` | 0 – 20 | שטאַרקייט פֿון פּראָמפּט־אנהאַלטונג פֿאַר בילד־אויסקלײַב, אויסגעדריקט ווי CFG (Classifier Free Guidance). |
| `real_cfg_scale` |  | number | no | `3.5` | 0 – 5 | שטאַרקייט פֿון פּראָמפּט־אנהאַלטונג פֿאַר בילד־אויסקלײַב, אויסגעדריקט ווי CFG (Classifier Free Guidance). |
| `use_real_cfg` |  | boolean | no | `false` |  | קלאַסישער CFG־באַשטימער, אויטאָמאַטיש אַקטיווירט מיט XLabs IP-Adapter v1. די guidance־פֿירונג שטימט מיט מאָדעלן ווי SD1.5 און SDXL. |
| `use_cfg_zero` |  | boolean | no | `false` |  | אַקטיוויזירט CFG-zero־איניציאַליזאַציע־סאַמפּלינג, באַשריבן אויף https://arxiv.org/abs/2503.18886. |
| `num_images` | `num_outputs` | integer | no | `1` | 1 – 10 | שטעלן וויפֿל בילדער צו גענערירן; די אויסקלײַב איז פאַרפעסטיקט אויף 1 ווען דער רעזולטאַט ווערט סטרימד. |
| `enable_safety_checker` |  | boolean | no | `true` |  | זיכערקייט־קאָנטראָל, וואָס גיט שוואַרצע בילדער אַנשטאָט פון בילדער וואָס ווערן אָפּגעצייכנט ווי נישט זיכער. true דערמעגלעכט קאָנטראָל; false דיסייבלט עס בלויז פֿאַר אָטעריזירטע חשבונות, בשעת בקשות אָן אָטעריזאַציע ווערן סייַ ווי סייַ אָפּגעקוקט. |
| `reference_image_url` |  | string (image URL) | no |  |  | בילד־URL גענוצט פֿאַר Reference-Only guidance. |
| `reference_strength` |  | number | no | `0.65` | -3 – 3 | ווירקונג פֿון רעפֿערענץ־בילד בעת reference_only־גענערירונג; אָן אַ צוגעשטעלטן רעפֿערענץ־בילד האָט די שטאַרקייט קיין ווירקונג נישט. |
| `reference_start` |  | number | no | `0` | 0 – 1 | אָנהייב־פּונקט פֿון רעפֿערענץ־guidance, אויסגעדריקט ווי אַ פּראָצענט פֿון אַלע טימסטעפּס. |
| `reference_end` |  | number | no | `1` | 0 – 1 | סוף־פּונקט פֿון רעפֿערענץ־guidance, אויסגעדריקט ווי אַ פּראָצענט פֿון אַלע טימסטעפּס. |
| `base_shift` |  | number | no | `0.5` | 0.01 – 5 | באַזע־שיפט וואָס ווערט אָנגעווענדט אויף פּלאַנירטע טימסטעפּס. |
| `max_shift` |  | number | no | `1.15` | 0.01 – 5 | מאַקסימום שיפט וואָס ווערט אָנגעווענדט אויף פּלאַנירטע טימסטעפּס. |
| `output_format` |  | enum (string) | no | `png` | `jpeg`, `png` | פֿײַל־פֿאָרמאַט פון דעם רעזולטירנדיקן בילד. |
| `use_beta_schedule` |  | boolean | no | `false` |  | קאָנטראָלירט צי מען זאָל נוצן beta sigmas. |
| `sigma_schedule` |  | string \| null | no |  |  | Sigma־פּלאַן וואָס ווערט גענוצט בעת דענאָיזינג. |
| `scheduler` |  | enum (string) | no | `euler` | `euler`, `dpmpp_2m` | Scheduler וואָס ווערט גענוצט בעת דענאָיזינג. |
| `negative_prompt` |  | string | no | `` |  | נעגאַטיווער פּראָמפּט וואָס ווערט לויטן סטאַנדאַרט פּראַסעסט מיט NAG צו אָפּהאַלטן די ספּעציפיצירטע אומגעוווּנטשענע שטריכן אין גענערירטע בילדער. |
| `nag_scale` |  | number | no | `3` | ≤ 10, > 1 | אומגעוווּנטשענע נעגאַטיווע־פּראָמפּט־אויסמײַדונג וואָס ווערט קאנטראלירט דורך דער NAG־סקאַלע: אַ העכערע סקאַלע מאַכט דאָס גענערירטע בילד ווייניקער ענלעך צו דער נעגאַטיווער באַשרײַבונג. |
| `nag_tau` |  | number | no | `2.5` | > 0 | NAG tau־באַשטעטיקונג פֿאַר נאָרמאַליזאַציע פֿון hidden state; רעקאָמענדירט ווערט עס נישט צו ענדערן. דערהייבן עס שוואַכט די נאָרמאַליזאַציע און קען ברענגען אומגעריכטע אָפּווייכונגען פֿונעם אָריגינעלן בילד. |
| `nag_alpha` |  | number | no | `0.25` | ≤ 1, > 0 | NAG alpha באַשטימט וויפֿל דער פּאָזיטיווער פּראָמפּט דרייט איבער די נאָרמאַליזירטע guidance וואָס צונויפֿמישט די פּאָזיטיווע און נעגאַטיווע פּראָמפּטס. די לעצטע געוויכט גיט דעם פּאָזיטיוון פּראָמפּט מער השפּעה ביי נידעריקערע באַשטעטיקונגען און רעדוצירט די איבערדרייונג ביי העכערע. |
| `nag_end` |  | number | no | `0.25` | ≤ 1, > 0 | NAG־cutoff אויסגעדריקט ווי אַ טייל פֿון די גענערירונג־סטעפּס. FLUX'ס אָריגינעלע attention־פּראַסעסערס נעמען איבער נאָך דעם ווי NAG איז געלאָפֿן פֿאַר יענעם ערשטן טייל. |
| `image_url` | `image` | string (image URL) | yes |  |  | בילד־URL וואָס צושטעלט דאָס ערשטע בילד. |
| `change_map_image_url` |  | string (image URL) | yes |  |  | URL צו דער change map. |
| `strength` |  | number | no | `0.85` | 0.01 – 1 | Differential diffusion־שטאַרקייט, פֿון אָפּהיטן דאָס אָריגינעלע ביי 0.0 ביז אַ גאַנצן נײַעם בילד ביי 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} | פֿײַל־אינפֿאָרמאַציע פֿאַר די גענערירטע בילדער. |
| `timings` | object |  |
| `seed` | integer | בילד־גענערירונג־סיד, אַרײַנגערעכנט דעם ראַנדאָם אויסגעקליבענעם ווערט אויב די אַרײַנגעבונג האט נישט אַרײַנגעגעבן קיין סיד; אַנדערש איבערחזרט עס דעם צוגעשטעלטן ווערט. |
| `has_nsfw_concepts` | array of boolean | ווײַזט צי NSFW־קאָנסעפּטן דערשײַנען אין די גענערירטע בילדער. |
| `prompt` | string | פּראָמפּט וואָס ווערט גענוצט בעת בילד־גענערירונג. |

## 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