# FLUX.1 [dev] with Controlnets and Loras · Rf Inversion API

> Prompt-based editing of a reference image through RF inversion

Edits the image at `image_url` according to a `prompt` using the RF-Inversion pipeline, which works from the original image rather than starting from noise. LoRAs, control LoRAs, ControlNets and a reference image can be added, and NAG settings (`nag_scale`, `nag_tau`, `nag_alpha`, `nag_end`) tune negative prompt steering.

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

## Pricing

Price: **$0.025 / 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.025 = 25 API credits (1 image × 25 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/rf-inversion` 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 guiding edits to the image. |
| `image_size` |  | object {width, height} \| enum (string) | no |  | `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | Dimensions of the generated image. |
| `num_inference_steps` |  | integer | no | `28` | 1 – 50 | Count of inference steps to run. |
| `seed` |  | integer \| null | no |  |  | Seed for reproducible images: an identical prompt and seed produce an identical image when the model version is unchanged. |
| `loras` |  | array of object {path, scale} | no | `[]` |  | LoRAs whose combined effect produces the generated image, with no limit on how many you supply. |
| `loras[].path` |  | string | yes |  |  | Location of the LoRA weights, specified as a URL or path. |
| `loras[].scale` |  | object \| number | no | `1` |  | Scaling applied to LoRA weights before they are merged into the base model. Supply a dictionary of the form {"layer_name":layer_scale} to set individual layer scales; unspecified layers use 1.0. |
| `control_loras` |  | array of object {path, scale, control_image_url, preprocess} | no | `[]` |  | Control-image LoRAs merged into a combined configuration for generating the final image; the number supplied is unrestricted. |
| `control_loras[].path` |  | string | yes |  |  | Location of the LoRA weights, specified as a URL or path. |
| `control_loras[].scale` |  | object \| number | no | `1` |  | Scaling applied to LoRA weights before they are merged into the base model. Supply a dictionary of the form {"layer_name":layer_scale} to set individual layer scales; unspecified layers use 1.0. |
| `control_loras[].control_image_url` |  | string (image URL) | yes |  |  | Image URL supplying the control image. |
| `control_loras[].preprocess` |  | enum (string) | no | `None` | `canny`, `depth`, `None` | Preprocessing method applied to the supplied image. |
| `controlnets` |  | array of object {path, config_url, variant, control_image_url, mask_image_url, mask_threshold, conditioning_scale, start_percentage, end_percentage} | no | `[]` |  | ControlNet configuration for image generation, currently limited to a single ControlNet. |
| `controlnets[].path` |  | string | yes |  |  | ControlNet weight location, specified as a URL or path. |
| `controlnets[].config_url` |  | string \| null | no |  |  | Optional URL pointing to the ControlNet's config.json file. |
| `controlnets[].variant` |  | string \| null | no |  |  | Optional variant for use with a Hugging Face repository key. |
| `controlnets[].control_image_url` |  | string (image URL) | yes |  |  | Image URL supplying the control image. |
| `controlnets[].mask_image_url` |  | string (image URL) | no |  |  | Mask URL associated with the control image. |
| `controlnets[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Mask threshold value. |
| `controlnets[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Scaling applied to ControlNet weights before they are merged into the base model. |
| `controlnets[].start_percentage` |  | number | no | `0` | 0 – 1 | Percentage of total timesteps at which ControlNet starts influencing image generation. |
| `controlnets[].end_percentage` |  | number | no | `1` | 0 – 1 | Percentage of total timesteps at which ControlNet stops influencing image generation. |
| `controlnet_unions` |  | array of object {path, config_url, variant, controls} | no | `[]` |  | ControlNet union configuration for image generation, subject to the current single-ControlNet restriction. |
| `controlnet_unions[].path` |  | string | yes |  |  | ControlNet weight location, specified as a URL or path. |
| `controlnet_unions[].config_url` |  | string \| null | no |  |  | Optional URL pointing to the ControlNet's config.json file. |
| `controlnet_unions[].variant` |  | string \| null | no |  |  | Optional variant for use with a Hugging Face repository key. |
| `controlnet_unions[].controls` |  | array of object {control_image_url, mask_image_url, control_mode, conditioning_scale, mask_threshold, start_percentage, end_percentage} | yes |  |  | Control images and associated modes supplied to the ControlNet. |
| `controlnet_unions[].controls[].control_image_url` |  | string (image URL) | yes |  |  | Image URL supplying the control image. |
| `controlnet_unions[].controls[].mask_image_url` |  | string (image URL) | no |  |  | Mask URL associated with the control image. |
| `controlnet_unions[].controls[].control_mode` |  | enum (string) | yes |  | `canny`, `tile`, `depth`, `blur`, `pose`, `gray`, `low-quality` | Control mode used by Flux Controlnet Union. Options: canny guides generation with edges; tile guides it with tiles; depth guides it with a grayscale depth map; blur blurs the image; pose guides generation with the image's pose; gray makes the image grayscale; low-quality produces a low-quality version of the image. |
| `controlnet_unions[].controls[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Scaling applied to ControlNet weights before they are merged into the base model. |
| `controlnet_unions[].controls[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Mask threshold value. |
| `controlnet_unions[].controls[].start_percentage` |  | number | no | `0` | 0 – 1 | Percentage of total timesteps at which ControlNet starts influencing image generation. |
| `controlnet_unions[].controls[].end_percentage` |  | number | no | `1` | 0 – 1 | Percentage of total timesteps at which ControlNet stops influencing image generation. |
| `easycontrols` |  | array of object {control_method_url, scale, image_url, image_control_type} | no | `[]` |  | EasyControl inputs applied during image generation. |
| `easycontrols[].control_method_url` |  | string | yes |  |  | Control method's safetensor weight URL, or a supported identifier: `canny`, `depth`, `hedsketch`, `inpainting`, `pose`, `seg`, `subject`, `ghibli`. |
| `easycontrols[].scale` |  | number | no | `1` | 0 – 2 | Control method scaling factor. |
| `easycontrols[].image_url` |  | string (image URL) | yes |  |  | Image URL supplying a control input. |
| `easycontrols[].image_control_type` |  | enum (string) | yes |  | `subject`, `spatial` | Image control mode; accepts either `spatial` or `subject`. |
| `fill_image` |  | object {fill_image_url} \| null | no |  |  | Input image that guides generation and can supply content for masked regions. |
| `fill_image.fill_image_url` |  | string (image URL) \| array of image URL | no | `[]` |  | Image URLs for filling via redux prompting. |
| `guidance_scale` |  | number | no | `3.5` | 0 – 20 | Prompt-adherence strength for image selection, expressed as CFG (Classifier Free Guidance). |
| `use_cfg_zero` |  | boolean | no | `false` |  | Enables CFG-zero initialization sampling, described at https://arxiv.org/abs/2503.18886. |
| `num_images` | `num_outputs` | integer | no | `1` | 1 – 10 | Set how many images to generate; this choice is fixed at 1 when output is streamed. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Safety checking, which returns black images in place of any images flagged unsafe. A value of true enables checking; false disables it only for authorized accounts, while requests without authorization are checked regardless. |
| `reference_image_url` |  | string (image URL) | no |  |  | Image URL used for Reference-Only guidance. |
| `reference_strength` |  | number | no | `0.65` | -3 – 3 | Reference-image influence during reference_only generation; without a supplied reference image, this strength setting has no effect. |
| `reference_start` |  | number | no | `0` | 0 – 1 | Reference guidance start point, expressed as a percentage of all timesteps. |
| `reference_end` |  | number | no | `1` | 0 – 1 | Reference guidance end point, expressed as a percentage of all timesteps. |
| `base_shift` |  | number | no | `0.5` | 0.01 – 5 | Baseline shift applied to scheduled timesteps. |
| `max_shift` |  | number | no | `1.15` | 0.01 – 5 | Maximum shift applied to scheduled timesteps. |
| `output_format` |  | enum (string) | no | `png` | `jpeg`, `png` | File format for the resulting image. |
| `use_beta_schedule` |  | boolean | no | `false` |  | Controls whether to use beta sigmas. |
| `sigma_schedule` |  | string \| null | no |  |  | Sigma schedule used during denoising. |
| `scheduler` |  | enum (string) | no | `euler` | `euler`, `dpmpp_2m` | Scheduler used during denoising. |
| `negative_prompt` |  | string | no | `` |  | Negative prompt processed with NAG by default to discourage the specified unwanted features in generated images. |
| `nag_scale` |  | number | no | `3` | ≤ 10, > 1 | Negative-prompt avoidance controlled by the NAG scale: increasing it makes the generated image less like the negative description. |
| `nag_tau` |  | number | no | `2.5` | > 0 | NAG tau setting for hidden-state normalization; leaving it unchanged is recommended. Raising it weakens normalization and risks unexpected departures from the original image. |
| `nag_alpha` |  | number | no | `0.25` | ≤ 1, > 0 | NAG alpha sets how much the positive prompt redirects normalized guidance combining the positive and negative prompts. This final weighting gives the positive prompt more influence at lower settings and reduces redirection at higher settings. |
| `nag_end` |  | number | no | `0.25` | ≤ 1, > 0 | NAG cutoff expressed as a proportion of the generation steps. FLUX's original attention processors take over after NAG has run for that initial proportion. |
| `image_url` | `image` | string (image URL) | yes |  |  | Image URL identifying the editing input. |
| `controller_guidance_forward` |  | number | no | `0.6` | 0.01 – 3 | Controller guidance (gamma) for generating structured noise. |
| `controller_guidance_reverse` |  | number | no | `0.75` | 0.01 – 3 | Set eta, the denoising controller's guidance value; an image more similar to the input is obtained with settings nearer 1. |
| `reverse_guidance_start` |  | integer | no | `0` |  | Starting timestep for guidance in the reverse process. |
| `reverse_guidance_end` |  | integer | no | `8` |  | Ending timestep for guidance in the reverse process. |
| `reverse_guidance_schedule` |  | enum (string) | no | `constant` | `constant`, `linear_increase`, `linear_decrease` | Schedule controlling the application of reverse guidance. |

File parameters (`reference_image_url`, `image`) 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"
}
```

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"
}
```

## 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/rf-inversion?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"
  }'

# 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/rf-inversion?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"
  }),
});
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",
}

# Run the model; wait up to 20 s for the finished result in the same call
r = requests.post(API + "/run/flux-general/rf-inversion", 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/rf-inversion",
      "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"
      },
      "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/rf-inversion",
  "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": 25,
    "usd": "0.025",
    "charged": 25,
    "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"
  },
  "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} | File information for the generated images. |
| `timings` | object |  |
| `seed` | integer | Image-generation seed, including the randomly chosen value if the input omitted a seed; otherwise, it repeats the supplied value. |
| `has_nsfw_concepts` | array of boolean | Indicates whether NSFW concepts appear in the generated images. |
| `prompt` | string | Prompt used during image generation. |

## 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 · Differential Diffusion](https://doitong.com/developers/models/flux-general/differential-diffusion.md) (`flux-general/differential-diffusion`): $0.138 / 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 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/rf-inversion
- 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/rf-inversion
- Errors: https://doitong.com/developers/docs/errors
- Model details as JSON: https://api.doitong.com/v1/models/flux-general/rf-inversion