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

> FLUX.1 [dev] Text-zu-Bild mit LoRAs, ControlNets, IP-Adaptern, EasyControl und Referenzbildsteuerung

Generiert Bilder aus einem `prompt` und ermöglicht mehrere Konditionierungsmethoden: `loras`, `control_loras`, `controlnets`, `controlnet_unions`, `ip_adapters` und `easycontrols` sowie `fill_image` für maskierte Bereiche. Außerdem werden eine `reference_image_url`, Negativ-Prompts und ein euler- oder dpmpp_2m-Scheduler unterstützt. Bis zu 10 Bilder pro Aufruf, als png oder jpeg.

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

## Pricing

Price: **$0.30 / 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.30 = 300 API credits (1 image × 300 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` 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 zur Steuerung der Bildgenerierung. |
| `image_size` |  | object {width, height} \| enum (string) | no |  | `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | Abmessungen des generierten Bildes. |
| `num_inference_steps` |  | integer | no | `28` | 1 – 50 | Anzahl der auszuführenden Inferenzschritte. |
| `seed` |  | integer \| null | no |  |  | Seed für reproduzierbare Bilder: Ein identischer Prompt und Seed erzeugen bei unveränderter Modellversion ein identisches Bild. |
| `loras` |  | array of object {path, scale} | no | `[]` |  | LoRAs, deren kombinierter Effekt das generierte Bild erzeugt; die Anzahl der angegebenen LoRAs ist unbegrenzt. |
| `loras[].path` |  | string | yes |  |  | Speicherort der LoRA-Gewichte, angegeben als URL oder Pfad. |
| `loras[].scale` |  | object \| number | no | `1` |  | Skalierung der LoRA-Gewichte vor dem Zusammenführen mit dem Basismodell. Ein Dictionary der Form {"layer_name":layer_scale} angeben, um einzelne Layer-Skalierungen festzulegen; nicht angegebene Layer verwenden 1.0. |
| `control_loras` |  | array of object {path, scale, control_image_url, preprocess} | no | `[]` |  | Control-Image-LoRAs, die zu einer kombinierten Konfiguration für die Generierung des finalen Bildes zusammengeführt werden; die Anzahl ist unbegrenzt. |
| `control_loras[].path` |  | string | yes |  |  | Speicherort der LoRA-Gewichte, angegeben als URL oder Pfad. |
| `control_loras[].scale` |  | object \| number | no | `1` |  | Skalierung der LoRA-Gewichte vor dem Zusammenführen mit dem Basismodell. Ein Dictionary der Form {"layer_name":layer_scale} angeben, um einzelne Layer-Skalierungen festzulegen; nicht angegebene Layer verwenden 1.0. |
| `control_loras[].control_image_url` |  | string (image URL) | yes |  |  | Bild-URL für das Steuerbild. |
| `control_loras[].preprocess` |  | enum (string) | no | `None` | `canny`, `depth`, `None` | Auf das bereitgestellte Bild angewendete Vorverarbeitungsmethode. |
| `controlnets` |  | array of object {path, config_url, variant, control_image_url, mask_image_url, mask_threshold, conditioning_scale, start_percentage, end_percentage} | no | `[]` |  | ControlNet-Konfiguration für die Bildgenerierung, derzeit auf ein einzelnes ControlNet begrenzt. |
| `controlnets[].path` |  | string | yes |  |  | Speicherort der ControlNet-Gewichte, angegeben als URL oder Pfad. |
| `controlnets[].config_url` |  | string \| null | no |  |  | Optionale URL zur config.json-Datei des ControlNet. |
| `controlnets[].variant` |  | string \| null | no |  |  | Optionale Variante zur Verwendung mit einem Hugging-Face-Repository-Schlüssel. |
| `controlnets[].control_image_url` |  | string (image URL) | yes |  |  | Bild-URL für das Steuerbild. |
| `controlnets[].mask_image_url` |  | string (image URL) | no |  |  | Mit dem Steuerbild verknüpfte Masken-URL. |
| `controlnets[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Schwellwert der Maske. |
| `controlnets[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Skalierung der ControlNet-Gewichte vor dem Zusammenführen mit dem Basismodell. |
| `controlnets[].start_percentage` |  | number | no | `0` | 0 – 1 | Prozentsatz der gesamten Zeitschritte, bei dem ControlNet beginnt, die Bildgenerierung zu beeinflussen. |
| `controlnets[].end_percentage` |  | number | no | `1` | 0 – 1 | Prozentsatz der gesamten Zeitschritte, bei dem ControlNet aufhört, die Bildgenerierung zu beeinflussen. |
| `controlnet_unions` |  | array of object {path, config_url, variant, controls} | no | `[]` |  | ControlNet-Union-Konfiguration für die Bildgenerierung, vorbehaltlich der aktuellen Beschränkung auf ein einzelnes ControlNet. |
| `controlnet_unions[].path` |  | string | yes |  |  | Speicherort der ControlNet-Gewichte, angegeben als URL oder Pfad. |
| `controlnet_unions[].config_url` |  | string \| null | no |  |  | Optionale URL zur config.json-Datei des ControlNet. |
| `controlnet_unions[].variant` |  | string \| null | no |  |  | Optionale Variante zur Verwendung mit einem Hugging-Face-Repository-Schlüssel. |
| `controlnet_unions[].controls` |  | array of object {control_image_url, mask_image_url, control_mode, conditioning_scale, mask_threshold, start_percentage, end_percentage} | yes |  |  | Control-Bilder und zugehörige Modi, die an das ControlNet übergeben werden. |
| `controlnet_unions[].controls[].control_image_url` |  | string (image URL) | yes |  |  | Bild-URL für das Steuerbild. |
| `controlnet_unions[].controls[].mask_image_url` |  | string (image URL) | no |  |  | Mit dem Steuerbild verknüpfte Masken-URL. |
| `controlnet_unions[].controls[].control_mode` |  | enum (string) | yes |  | `canny`, `tile`, `depth`, `blur`, `pose`, `gray`, `low-quality` | Von Flux Controlnet Union verwendeter Control-Modus. Optionen: canny steuert die Generierung mit Kanten; tile mit Kacheln; depth mit einer Graustufen-Tiefenkarte; blur verwischt das Bild; pose steuert mit der Pose des Bildes; gray wandelt das Bild in Graustufen um; low-quality erzeugt eine Version mit niedriger Bildqualität. |
| `controlnet_unions[].controls[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Skalierung der ControlNet-Gewichte vor dem Zusammenführen mit dem Basismodell. |
| `controlnet_unions[].controls[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Schwellwert der Maske. |
| `controlnet_unions[].controls[].start_percentage` |  | number | no | `0` | 0 – 1 | Prozentsatz der gesamten Zeitschritte, bei dem ControlNet beginnt, die Bildgenerierung zu beeinflussen. |
| `controlnet_unions[].controls[].end_percentage` |  | number | no | `1` | 0 – 1 | Prozentsatz der gesamten Zeitschritte, bei dem ControlNet aufhört, die Bildgenerierung zu beeinflussen. |
| `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 | `[]` |  | Während der Bildgenerierung angewendeter IP-Adapter. |
| `ip_adapters[].path` |  | string | yes |  |  | IP-Adapter-Speicherort auf Hugging Face. |
| `ip_adapters[].subfolder` |  | string \| null | no |  |  | Unterordner mit den ip_adapter-Gewichten. |
| `ip_adapters[].weight_name` |  | string \| null | no |  |  | Safetensors-Dateiname der IP-Adapter-Gewichte. |
| `ip_adapters[].image_encoder_path` |  | string | yes |  |  | Speicherort des IP-Adapter-Bildencoders, z. B. 'openai/clip-vit-large-patch14'. |
| `ip_adapters[].image_encoder_subfolder` |  | string \| null | no |  |  | Unterordner mit den Gewichten des Bildencoders. |
| `ip_adapters[].image_encoder_weight_name` |  | string \| null | no |  |  | Name des Bildencoders. |
| `ip_adapters[].image_url` |  | string (image URL) | yes |  |  | An den IP-Adapter übergebene URL des Konditionierungsbildes. |
| `ip_adapters[].mask_image_url` |  | string (image URL) \| null | no |  |  | Mit dem Steuerbild verknüpfte Masken-URL. |
| `ip_adapters[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Schwellwert der Maske. |
| `ip_adapters[].scale` |  | number | yes |  |  | Skalierungsfaktor des IP-Adapters. |
| `easycontrols` |  | array of object {control_method_url, scale, image_url, image_control_type} | no | `[]` |  | Während der Bildgenerierung angewendete EasyControl-Eingaben. |
| `easycontrols[].control_method_url` |  | string | yes |  |  | Safetensor-Gewichts-URL der Steuermethode oder eine unterstützte Kennung: `canny`, `depth`, `hedsketch`, `inpainting`, `pose`, `seg`, `subject`, `ghibli`. |
| `easycontrols[].scale` |  | number | no | `1` | 0 – 2 | Skalierungsfaktor der Steuermethode. |
| `easycontrols[].image_url` |  | string (image URL) | yes |  |  | Bild-URL für eine Steuereingabe. |
| `easycontrols[].image_control_type` |  | enum (string) | yes |  | `subject`, `spatial` | Bildsteuerungsmodus; akzeptiert entweder `spatial` oder `subject`. |
| `fill_image` |  | object {fill_image_url} \| null | no |  |  | Eingabebild, das die Generierung steuert und Inhalte für maskierte Bereiche liefern kann. |
| `fill_image.fill_image_url` |  | string (image URL) \| array of image URL | no | `[]` |  | Bild-URLs zum Füllen durch Redux-Prompting. |
| `guidance_scale` |  | number | no | `3.5` | 0 – 20 | Stärke der Prompt-Treue bei der Bildauswahl, ausgedrückt als CFG (Classifier Free Guidance). |
| `real_cfg_scale` |  | number | no | `3.5` | 0 – 5 | Stärke der Prompt-Treue bei der Bildauswahl, ausgedrückt als CFG (Classifier Free Guidance). |
| `use_real_cfg` |  | boolean | no | `false` |  | Schalter für klassisches CFG, automatisch mit XLabs IP-Adapter v1 aktiviert. Das Guidance-Verhalten entspricht dem von Modellen wie SD1.5 und SDXL. |
| `use_cfg_zero` |  | boolean | no | `false` |  | Aktiviert das CFG-zero-Initialisierungssampling, beschrieben unter https://arxiv.org/abs/2503.18886. |
| `num_images` | `num_outputs` | integer | no | `1` | 1 – 10 | Festlegen, wie viele Bilder generiert werden; bei gestreamter Ausgabe ist diese Auswahl fest auf 1 gesetzt. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Sicherheitsprüfung, die anstelle als unsicher markierter Bilder schwarze Bilder zurückgibt. true aktiviert die Prüfung; false deaktiviert sie nur für autorisierte Konten, während nicht autorisierte Anfragen unabhängig davon geprüft werden. |
| `reference_image_url` |  | string (image URL) | no |  |  | Bild-URL für Reference-Only-Guidance. |
| `reference_strength` |  | number | no | `0.65` | -3 – 3 | Einfluss des Referenzbildes während der reference_only-Generierung; ohne bereitgestelltes Referenzbild hat diese Stärkeeinstellung keine Wirkung. |
| `reference_start` |  | number | no | `0` | 0 – 1 | Startpunkt der Referenz-Guidance, angegeben als Prozentsatz aller Zeitschritte. |
| `reference_end` |  | number | no | `1` | 0 – 1 | Endpunkt der Referenz-Guidance, angegeben als Prozentsatz aller Zeitschritte. |
| `base_shift` |  | number | no | `0.5` | 0.01 – 5 | Auf geplante Zeitschritte angewendete Basisverschiebung. |
| `max_shift` |  | number | no | `1.15` | 0.01 – 5 | Auf geplante Zeitschritte angewendete maximale Verschiebung. |
| `output_format` |  | enum (string) | no | `png` | `jpeg`, `png` | Dateiformat des resultierenden Bilds. |
| `use_beta_schedule` |  | boolean | no | `false` |  | Steuert, ob Beta-Sigmas verwendet werden. |
| `sigma_schedule` |  | string \| null | no |  |  | Während des Entrauschens verwendeter Sigma-Zeitplan. |
| `scheduler` |  | enum (string) | no | `euler` | `euler`, `dpmpp_2m` | Während des Entrauschens verwendeter Scheduler. |
| `negative_prompt` |  | string | no | `` |  | Negativer Prompt, der standardmäßig mit NAG verarbeitet wird, um die angegebenen unerwünschten Merkmale in generierten Bildern zu vermeiden. |
| `nag_scale` |  | number | no | `3` | ≤ 10, > 1 | Vermeidung des negativen Prompts, gesteuert durch die NAG-Skalierung: Eine Erhöhung bewirkt, dass das generierte Bild der negativen Beschreibung weniger ähnelt. |
| `nag_tau` |  | number | no | `2.5` | > 0 | NAG-Tau-Einstellung für die Normalisierung des Hidden State; es wird empfohlen, sie unverändert zu lassen. Eine Erhöhung schwächt die Normalisierung und birgt das Risiko unerwarteter Abweichungen vom Originalbild. |
| `nag_alpha` |  | number | no | `0.25` | ≤ 1, > 0 | NAG-Alpha legt fest, wie stark der positive Prompt die normalisierte Guidance umleitet, die den positiven und negativen Prompt kombiniert. Diese endgültige Gewichtung verleiht dem positiven Prompt bei niedrigeren Einstellungen mehr Einfluss und reduziert die Umleitung bei höheren Einstellungen. |
| `nag_end` |  | number | no | `0.25` | ≤ 1, > 0 | NAG-Abschaltpunkt, ausgedrückt als Anteil der Generierungsschritte. FLUXs ursprüngliche Attention-Prozessoren übernehmen, nachdem NAG während dieses anfänglichen Anteils ausgeführt wurde. |

File parameters (`reference_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"
}
```

A fuller example:

```json
{
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field"
}
```

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

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

# Run the model; wait up to 20 s for the finished result in the same call
r = requests.post(API + "/run/flux-general", 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",
      "input": {
        "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field"
      },
      "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",
  "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": 300,
    "usd": "0.30",
    "charged": 300,
    "refunded": 0
  },
  "input": {
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field"
  },
  "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} | Dateiinformationen für die generierten Bilder. |
| `timings` | object |  |
| `seed` | integer | Seed der Bildgenerierung einschließlich des zufällig gewählten Werts, falls die Eingabe keinen Seed enthielt; andernfalls wird der angegebene Wert wiederholt. |
| `has_nsfw_concepts` | array of boolean | Gibt an, ob NSFW-Konzepte in den generierten Bildern vorkommen. |
| `prompt` | string | Während der Bildgenerierung verwendeter Prompt. |

## Related models

- [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 \[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 \[dev\]](https://doitong.com/developers/models/flux/dev.md) (`flux/dev`): $0.025 / megapixel
- [FLUX.1 \[schnell\]](https://doitong.com/developers/models/flux/schnell.md) (`flux/schnell`): $0.003 / megapixel
- [FLUX.2 \[dev\]](https://doitong.com/developers/models/flux-2.md) (`flux-2`): $0.012 / megapixel
- [FLUX.2 \[pro\]](https://doitong.com/developers/models/flux-2-pro.md) (`flux-2-pro`): $0.015 / megapixel of output image

## Links

- HTML page: https://doitong.com/developers/models/flux-general
- 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
- Errors: https://doitong.com/developers/docs/errors
- Model details as JSON: https://api.doitong.com/v1/models/flux-general