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

> FLUX.1 [dev] de texto a imagen con LoRAs, ControlNets, IP-Adapters, EasyControl y guía mediante imágenes de referencia

Genera imágenes a partir de un `prompt` y permite varios métodos de condicionamiento: `loras`, `control_loras`, `controlnets`, `controlnet_unions`, `ip_adapters` y `easycontrols`, además de `fill_image` para áreas enmascaradas. También admite un `reference_image_url`, prompts negativos y los planificadores euler o dpmpp_2m. Hasta 10 imágenes por llamada, en png o 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/es/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 que orienta la generación de imágenes. |
| `image_size` |  | object {width, height} \| enum (string) | no |  | `square_hd`, `square`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9` | Dimensiones de la imagen generada. |
| `num_inference_steps` |  | integer | no | `28` | 1 – 50 | Cantidad de pasos de inferencia que se ejecutarán. |
| `seed` |  | integer \| null | no |  |  | Seed para obtener imágenes reproducibles: un prompt y una seed idénticos producen una imagen idéntica cuando la versión del modelo no cambia. |
| `loras` |  | array of object {path, scale} | no | `[]` |  | LoRA cuyo efecto combinado produce la imagen generada, sin límite en la cantidad proporcionada. |
| `loras[].path` |  | string | yes |  |  | Ubicación de los pesos de LoRA, especificada como URL o ruta. |
| `loras[].scale` |  | object \| number | no | `1` |  | Escala aplicada a los pesos de LoRA antes de combinarlos con el modelo base. Proporciona un diccionario con el formato {"layer_name":layer_scale} para establecer escalas de capas individuales; las capas no especificadas usan 1.0. |
| `control_loras` |  | array of object {path, scale, control_image_url, preprocess} | no | `[]` |  | LoRA de imágenes de control combinados en una configuración para generar la imagen final; no hay límite en la cantidad proporcionada. |
| `control_loras[].path` |  | string | yes |  |  | Ubicación de los pesos de LoRA, especificada como URL o ruta. |
| `control_loras[].scale` |  | object \| number | no | `1` |  | Escala aplicada a los pesos de LoRA antes de combinarlos con el modelo base. Proporciona un diccionario con el formato {"layer_name":layer_scale} para establecer escalas de capas individuales; las capas no especificadas usan 1.0. |
| `control_loras[].control_image_url` |  | string (image URL) | yes |  |  | URL de la imagen que proporciona la imagen de control. |
| `control_loras[].preprocess` |  | enum (string) | no | `None` | `canny`, `depth`, `None` | Método de preprocesamiento aplicado a la imagen proporcionada. |
| `controlnets` |  | array of object {path, config_url, variant, control_image_url, mask_image_url, mask_threshold, conditioning_scale, start_percentage, end_percentage} | no | `[]` |  | Configuración de ControlNet para la generación de imágenes, actualmente limitada a un único ControlNet. |
| `controlnets[].path` |  | string | yes |  |  | Ubicación de los pesos de ControlNet, especificada como una URL o ruta. |
| `controlnets[].config_url` |  | string \| null | no |  |  | URL opcional que apunta al archivo config.json de ControlNet. |
| `controlnets[].variant` |  | string \| null | no |  |  | Variante opcional para usar con una clave de repositorio de Hugging Face. |
| `controlnets[].control_image_url` |  | string (image URL) | yes |  |  | URL de la imagen que proporciona la imagen de control. |
| `controlnets[].mask_image_url` |  | string (image URL) | no |  |  | URL de la máscara asociada a la imagen de control. |
| `controlnets[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Valor de umbral de la máscara. |
| `controlnets[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Escala aplicada a los pesos de ControlNet antes de combinarlos con el modelo base. |
| `controlnets[].start_percentage` |  | number | no | `0` | 0 – 1 | Porcentaje del total de pasos de tiempo en el que ControlNet comienza a influir en la generación de imágenes. |
| `controlnets[].end_percentage` |  | number | no | `1` | 0 – 1 | Porcentaje del total de pasos de tiempo en el que ControlNet deja de influir en la generación de imágenes. |
| `controlnet_unions` |  | array of object {path, config_url, variant, controls} | no | `[]` |  | Configuración de unión de ControlNet para la generación de imágenes, sujeta a la restricción actual de un único ControlNet. |
| `controlnet_unions[].path` |  | string | yes |  |  | Ubicación de los pesos de ControlNet, especificada como una URL o ruta. |
| `controlnet_unions[].config_url` |  | string \| null | no |  |  | URL opcional que apunta al archivo config.json de ControlNet. |
| `controlnet_unions[].variant` |  | string \| null | no |  |  | Variante opcional para usar con una clave de repositorio de 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 |  |  | Imágenes de control y modos asociados proporcionados a ControlNet. |
| `controlnet_unions[].controls[].control_image_url` |  | string (image URL) | yes |  |  | URL de la imagen que proporciona la imagen de control. |
| `controlnet_unions[].controls[].mask_image_url` |  | string (image URL) | no |  |  | URL de la máscara asociada a la imagen de control. |
| `controlnet_unions[].controls[].control_mode` |  | enum (string) | yes |  | `canny`, `tile`, `depth`, `blur`, `pose`, `gray`, `low-quality` | Modo de control utilizado por Flux Controlnet Union. Opciones: canny guía la generación con bordes; tile la guía con mosaicos; depth la guía con un mapa de profundidad en escala de grises; blur desenfoca la imagen; pose guía la generación con la pose de la imagen; gray convierte la imagen a escala de grises; low-quality produce una versión de baja calidad de la imagen. |
| `controlnet_unions[].controls[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Escala aplicada a los pesos de ControlNet antes de combinarlos con el modelo base. |
| `controlnet_unions[].controls[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Valor de umbral de la máscara. |
| `controlnet_unions[].controls[].start_percentage` |  | number | no | `0` | 0 – 1 | Porcentaje del total de pasos de tiempo en el que ControlNet comienza a influir en la generación de imágenes. |
| `controlnet_unions[].controls[].end_percentage` |  | number | no | `1` | 0 – 1 | Porcentaje del total de pasos de tiempo en el que ControlNet deja de influir en la generación de imágenes. |
| `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 aplicado durante la generación de imágenes. |
| `ip_adapters[].path` |  | string | yes |  |  | Ubicación de IP-Adapter en Hugging Face. |
| `ip_adapters[].subfolder` |  | string \| null | no |  |  | Subcarpeta que contiene los pesos de ip_adapter. |
| `ip_adapters[].weight_name` |  | string \| null | no |  |  | Nombre de archivo Safetensors de los pesos de IP-Adapter. |
| `ip_adapters[].image_encoder_path` |  | string | yes |  |  | Ubicación del codificador de imágenes de IP-Adapter, como 'openai/clip-vit-large-patch14'. |
| `ip_adapters[].image_encoder_subfolder` |  | string \| null | no |  |  | Subcarpeta que contiene los pesos del codificador de imágenes. |
| `ip_adapters[].image_encoder_weight_name` |  | string \| null | no |  |  | Nombre del codificador de imágenes. |
| `ip_adapters[].image_url` |  | string (image URL) | yes |  |  | URL de la imagen de condicionamiento proporcionada a IP-Adapter. |
| `ip_adapters[].mask_image_url` |  | string (image URL) \| null | no |  |  | URL de la máscara asociada a la imagen de control. |
| `ip_adapters[].mask_threshold` |  | number | no | `0.5` | 0.01 – 0.99 | Valor de umbral de la máscara. |
| `ip_adapters[].scale` |  | number | yes |  |  | Factor de escala de IP-Adapter. |
| `easycontrols` |  | array of object {control_method_url, scale, image_url, image_control_type} | no | `[]` |  | Entradas de EasyControl aplicadas durante la generación de imágenes. |
| `easycontrols[].control_method_url` |  | string | yes |  |  | URL de los pesos safetensor del método de control o identificador compatible: `canny`, `depth`, `hedsketch`, `inpainting`, `pose`, `seg`, `subject`, `ghibli`. |
| `easycontrols[].scale` |  | number | no | `1` | 0 – 2 | Factor de escala del método de control. |
| `easycontrols[].image_url` |  | string (image URL) | yes |  |  | URL de la imagen que proporciona una entrada de control. |
| `easycontrols[].image_control_type` |  | enum (string) | yes |  | `subject`, `spatial` | Modo de control de imagen; acepta `spatial` o `subject`. |
| `fill_image` |  | object {fill_image_url} \| null | no |  |  | Imagen de entrada que guía la generación y puede proporcionar contenido para regiones enmascaradas. |
| `fill_image.fill_image_url` |  | string (image URL) \| array of image URL | no | `[]` |  | URLs de imágenes para rellenar mediante prompting redux. |
| `guidance_scale` |  | number | no | `3.5` | 0 – 20 | Intensidad de adhesión al prompt para la selección de imágenes, expresada como CFG (Classifier Free Guidance). |
| `real_cfg_scale` |  | number | no | `3.5` | 0 – 5 | Intensidad de adhesión al prompt para la selección de imágenes, expresada como CFG (Classifier Free Guidance). |
| `use_real_cfg` |  | boolean | no | `false` |  | Interruptor de CFG clásico, activado automáticamente con XLabs IP-Adapter v1. El comportamiento de guidance coincide con el de modelos como SD1.5 y SDXL. |
| `use_cfg_zero` |  | boolean | no | `false` |  | Activa el muestreo de inicialización CFG-zero, descrito en https://arxiv.org/abs/2503.18886. |
| `num_images` | `num_outputs` | integer | no | `1` | 1 – 10 | Establece cuántas imágenes se generarán; esta opción se fija en 1 cuando la salida se transmite. |
| `enable_safety_checker` |  | boolean | no | `true` |  | Comprobación de seguridad que devuelve imágenes negras en lugar de las imágenes marcadas como no seguras. Un valor true activa la comprobación; false la desactiva solo para cuentas autorizadas, mientras que las solicitudes sin autorización se comprueban siempre. |
| `reference_image_url` |  | string (image URL) | no |  |  | URL de la imagen utilizada para guidance Reference-Only. |
| `reference_strength` |  | number | no | `0.65` | -3 – 3 | Influencia de la imagen de referencia durante la generación reference_only; sin una imagen de referencia proporcionada, esta configuración de intensidad no tiene efecto. |
| `reference_start` |  | number | no | `0` | 0 – 1 | Punto inicial de guidance de referencia, expresado como porcentaje de todos los pasos de tiempo. |
| `reference_end` |  | number | no | `1` | 0 – 1 | Punto final de guidance de referencia, expresado como porcentaje de todos los pasos de tiempo. |
| `base_shift` |  | number | no | `0.5` | 0.01 – 5 | Desplazamiento base aplicado a los pasos de tiempo programados. |
| `max_shift` |  | number | no | `1.15` | 0.01 – 5 | Desplazamiento máximo aplicado a los pasos de tiempo programados. |
| `output_format` |  | enum (string) | no | `png` | `jpeg`, `png` | Formato de archivo de la imagen resultante. |
| `use_beta_schedule` |  | boolean | no | `false` |  | Controla si se utilizan sigmas beta. |
| `sigma_schedule` |  | string \| null | no |  |  | Programación de sigmas utilizada durante la eliminación de ruido. |
| `scheduler` |  | enum (string) | no | `euler` | `euler`, `dpmpp_2m` | Programador utilizado durante la eliminación de ruido. |
| `negative_prompt` |  | string | no | `` |  | Prompt negativo procesado con NAG de forma predeterminada para desalentar las características no deseadas especificadas en las imágenes generadas. |
| `nag_scale` |  | number | no | `3` | ≤ 10, > 1 | Evitación del prompt negativo controlada por la escala NAG: aumentarla hace que la imagen generada se parezca menos a la descripción negativa. |
| `nag_tau` |  | number | no | `2.5` | > 0 | Configuración tau de NAG para la normalización del estado oculto; se recomienda no modificarla. Aumentarla debilita la normalización y puede provocar desviaciones inesperadas respecto a la imagen original. |
| `nag_alpha` |  | number | no | `0.25` | ≤ 1, > 0 | NAG alpha establece cuánto redirige el prompt positivo la guidance normalizada que combina los prompts positivo y negativo. Esta ponderación final da más influencia al prompt positivo con valores bajos y reduce la redirección con valores altos. |
| `nag_end` |  | number | no | `0.25` | ≤ 1, > 0 | Corte de NAG expresado como proporción de los pasos de generación. Los procesadores de atención originales de FLUX toman el control después de que NAG se haya ejecutado durante esa proporción inicial. |

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} | Información de los archivos de las imágenes generadas. |
| `timings` | object |  |
| `seed` | integer | Semilla de generación de imágenes, incluido el valor elegido aleatoriamente si la entrada omitió una semilla; de lo contrario, repite el valor proporcionado. |
| `has_nsfw_concepts` | array of boolean | Indica si aparecen conceptos NSFW en las imágenes generadas. |
| `prompt` | string | Prompt utilizado durante la generación de imágenes. |

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