# Stable Diffusion with LoRAs · Inpaint API

> Inpainting avec modèle de base Stable Diffusion choisi et LoRAs, guidé par un masque noir et blanc

Modifie des parties d'une image à l'aide de `image_url` et d'un `mask_url` noir et blanc avec un modèle Stable Diffusion défini dans `model_name`. `noise_strength` va de 0 à 1. Prend en charge les LoRAs fusionnés, embeddings, ControlNets, adaptateurs IP et plusieurs ordonnanceurs, avec 1 à 150 étapes. La sortie est en png ou jpeg.

- Model id: `lora/inpaint`
- Made by: Open model
- Category: Image Editing
- Output: image
- Estimated price per run: $0.184 / image (cheapest run $0.184 (184 API credits))
- Run: `POST https://api.doitong.com/v1/run/lora/inpaint`
- Quote: `POST https://api.doitong.com/v1/quote/lora/inpaint`
- Docs page: https://doitong.com/fr/developers/models/lora/inpaint

## Pricing

Price: **$0.184 / 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.184 = 184 API credits (1 image × 184 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/lora/inpaint` 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 |
|---|---|---|---|---|---|---|
| `model_name` |  | string | yes |  |  | Modèle de base pour générer l’image, identifié par une URL ou un identifiant HuggingFace. |
| `unet_name` |  | string \| null | no |  |  | Sélection d’un U-Net personnalisé pour générer des images ; fournissez son ID HuggingFace ou son URL. |
| `variant` |  | string \| null | no |  |  | Sélection de variante du modèle HuggingFace ; 'fp16' est un exemple. |
| `prompt` |  | string | yes |  |  | Décrivez l’image que vous souhaitez générer avec le plus de détails possible pour obtenir les meilleurs résultats. |
| `negative_prompt` |  | string | no | `` |  | Prompt négatif indiquant les détails d’image indésirables. Il peut exclure les couleurs, les objets, le décor ou des caractéristiques et qualités plus fines, comme une moustache, du flou ou une faible résolution. |
| `prompt_weighting` |  | boolean | no | `false` |  | Activation de la pondération du prompt : true supprime la limite de 77 jetons grâce à la moyenne des embeddings et active la syntaxe de pondération. |
| `image_url` | `image` | string (image URL) \| null | no |  |  | URL de l'image source pour la génération image-vers-image ou l'inpainting. |
| `mask_url` | `mask` | string (image URL) \| null | no |  |  | URL du masque d'inpainting pointant vers une image en noir et blanc. |
| `noise_strength` |  | number | no | `0.5` | ≤ 1, > 0 | Contrôle le bruit ajouté à l'image sur une échelle où 1.0 signifie un bruit complet et les valeurs proches de 0 un bruit minimal. S'applique uniquement lorsqu'une image_url est fournie. |
| `loras` |  | array of object {path, scale} | no | `[]` |  | LoRAs dont l’effet combiné produit l’image générée, sans limite quant au nombre fourni. |
| `loras[].path` |  | string | yes |  |  | Emplacement des poids LoRA, indiqué sous forme d’URL ou de chemin. |
| `loras[].scale` |  | number | no | `1` | 0 – 4 | Multiplicateur appliqué au poids LoRA avant sa fusion avec le modèle de base. |
| `embeddings` |  | array of object {path, tokens} | no | `[]` |  | Embeddings appliqués pendant la génération d'images pour associer les jetons du prompt aux poids des embeddings. Actuellement, un seul embedding est pris en charge. |
| `embeddings[].path` |  | string | yes |  |  | Poids de l'embedding spécifiés par URL ou chemin de fichier. |
| `embeddings[].tokens` |  | array of string \| null | no |  |  | Jetons du prompt associés aux poids des embeddings. Leur omission crée un jeton par vecteur du fichier d'embedding, nommé <s0>, <s1>, ... ; utilisez les jetons associés dans vos prompts. |
| `controlnets` |  | array of object {path, config_url, variant, image_url, mask_url, conditioning_scale, start_percentage, end_percentage, ip_adapter_index} | no | `[]` |  | Control nets planifiés pour être appliqués à l'image à des pas de temps spécifiés pendant la génération, sans limite quant à leur nombre. |
| `controlnets[].path` |  | string | yes |  |  | Emplacement des poids ControlNet, indiqué sous forme d’URL ou de chemin. |
| `controlnets[].config_url` |  | string \| null | no |  |  | URL facultative vers le fichier config.json de ControlNet. |
| `controlnets[].variant` |  | string \| null | no |  |  | Variante facultative à utiliser avec une clé de dépôt Hugging Face. |
| `controlnets[].image_url` |  | string (image URL) | yes |  |  | URL de l'image fournie comme entrée du ControlNet. |
| `controlnets[].mask_url` |  | string (image URL) \| null | no |  |  | Masque du ControlNet, qui doit avoir la même taille que l'image de contrôle s'il est fourni ; la largeur et la hauteur doivent être divisibles par 32. |
| `controlnets[].conditioning_scale` |  | number | no | `1` | 0 – 2 | Mise à l’échelle appliquée aux poids ControlNet avant leur fusion avec le modèle de base. |
| `controlnets[].start_percentage` |  | number | no | `0` | 0 – 1 | Pourcentage du nombre total d’étapes temporelles auquel ControlNet commence à influencer la génération de l’image. |
| `controlnets[].end_percentage` |  | number | no | `1` | 0 – 1 | Pourcentage du nombre total d’étapes temporelles auquel ControlNet cesse d’influencer la génération de l’image. |
| `controlnets[].ip_adapter_index` |  | integer \| null | no |  |  | Sélection de l'adaptateur IP par index pour un ControlNet InstantID ; les autres ControlNets n'ont pas besoin de ce paramètre. |
| `controlnet_guess_mode` |  | boolean | no | `false` |  | Restreint l'application du ControlNet aux prédictions conditionnelles lorsque la valeur est true. |
| `ip_adapter` |  | array of object {ip_adapter_image_url, ip_adapter_mask_url, path, model_subfolder, weight_name, insight_face_model_path, scale, scale_json, unconditional_noising_factor, image_projection_shortcut} | no | `[]` |  | Adaptateurs IP utilisés pour générer des images. La présence d'une entrée quelconque nécessite image_encoder_path. |
| `ip_adapter[].ip_adapter_image_url` |  | string (image URL) \| array of image URL | yes |  |  | URL de l'image fournie comme entrée de l'adaptateur IP. |
| `ip_adapter[].ip_adapter_mask_url` |  | string (image URL) \| null | no |  |  | Masque de l'adaptateur IP, soumis à une contrainte de taille lorsqu'il est fourni : ses dimensions doivent être égales à celles de l'image de l'adaptateur. |
| `ip_adapter[].path` |  | string | yes |  |  | Emplacement des poids de l'adaptateur IP, indiqué sous forme d'URL ou de chemin. |
| `ip_adapter[].model_subfolder` |  | string \| null | no |  |  | Emplacement des poids de l'adaptateur IP, indiqué comme sous-dossier du répertoire du modèle. |
| `ip_adapter[].weight_name` |  | string \| null | no |  |  | Nom de fichier des poids. |
| `ip_adapter[].insight_face_model_path` |  | string \| null | no |  |  | Emplacement des poids du modèle InsightFace, indiqué sous forme d'URL ou de chemin. |
| `ip_adapter[].scale` |  | number | no | `1` | ≥ 0 | Facteur d'échelle des poids de l'adaptateur IP, appliqué avant leur fusion dans le modèle de base. |
| `ip_adapter[].scale_json` |  | object \| null | no |  |  | Facteur d'échelle des poids de l'adaptateur IP, appliqué avant leur fusion dans le modèle de base. |
| `ip_adapter[].unconditional_noising_factor` |  | number | no | `0` | 0 – 1 | Facteur contrôlant le bruitage inconditionnel de l'adaptateur IP. |
| `ip_adapter[].image_projection_shortcut` |  | boolean | no | `true` |  | Paramètre de raccourci de projection d'image, avec True par défaut. Utilisez False pour les modèles FaceID plus V1 et True pour les modèles FaceID plus V2. |
| `image_encoder_path` |  | string \| null | no |  |  | Encodeur d'image indiqué par une URL HTTPS ou un identifiant Hugging Face, avec une compatibilité déterminée par les poids de l'IP-Adapter : SD1.5 utilise image_encoder_subfolder='models/image_encoder', tandis que h94/IP-Adapter SDXL utilise h94/IP-Adapter et image_encoder_subfolder='sdxl_models/image_encoder'. Un encodeur est requis dès que ip_adapter contient une valeur. |
| `image_encoder_subfolder` |  | string \| null | no |  |  | Sous-répertoire de image_encoder_path contenant les poids de l'encodeur d'image. |
| `image_encoder_weight_name` |  | string \| null | no | `pytorch_model.bin` |  | Sélectionnez par nom les poids de l'encodeur d'image à utiliser pour générer des images. |
| `ic_light_model_url` |  | string \| null | no |  |  | URL du modèle IC Light utilisé lors de la génération d'images. |
| `ic_light_model_background_image_url` |  | string (image URL) \| null | no |  |  | Arrière-plan compatible avec le modèle pour la génération d'images IC Light, fourni sous forme d'URL d'image. |
| `ic_light_image_url` |  | string (image URL) \| null | no |  |  | URL de l'image d'entrée pour la génération avec le modèle IC Light. |
| `seed` |  | integer \| null | no |  |  | Graine permettant de reproduire des images dans Stable Diffusion. Une image peut être reproduite exactement à chaque exécution en conservant la version du modèle, le prompt et la graine inchangés. |
| `num_inference_steps` |  | integer | no | `30` | 1 – 150 | Contrôle le nombre d'étapes de génération effectuées par Stable Diffusion ; des étapes supplémentaires peuvent produire une image finale plus détaillée. |
| `guidance_scale` |  | number | no | `7.5` | 0 – 20 | Force d'adhérence au prompt pour la sélection d'image, exprimée comme CFG (Classifier Free Guidance). |
| `clip_skip` |  | integer | no | `0` | 0 – 2 | Ignore une partie de la génération d'image pour accélérer le rendu, au prix de résultats légèrement différents. |
| `scheduler` |  | enum (string) \| null | no |  | `DPM++ 2M`, `DPM++ 2M Karras`, `DPM++ 2M SDE`, `DPM++ 2M SDE Karras`, `Euler`, `Euler A`, `Euler (trailing timesteps)`, `LCM`, `LCM (trailing timesteps)`, `DDIM`, `TCD` | Scheduler ou sampler utilisé pour débruiter l'image. |
| `timesteps` |  | object {method, array} | no | `{"array":[],"method":"default"}` |  | Surcharge du calendrier des pas de débruitage, mutuellement exclusive avec sigmas. Sans surcharge — le comportement par défaut — le planificateur calcule les pas à partir de num_inference_steps ; la fourniture d'un calendrier personnalisé rend num_inference_steps sans effet. Une surcharge nécessite que le planificateur prenne en charge l'argument timesteps pour set_timesteps. |
| `timesteps.method` |  | enum (string) | no | `default` | `default`, `array` | Choisissez comment les pas de temps sont déterminés : 'default', le paramètre par défaut, permet au planificateur d'utiliser `num_inference_steps`. Pour fournir vous-même un calendrier de pas de temps, sélectionnez 'array' et placez le calendrier dans le champ `array`. |
| `timesteps.array` |  | array of integer | no | `[]` |  | Calendrier des pas de temps appliqué lorsque la méthode sélectionnée est 'custom'. |
| `sigmas` |  | object {method, array} | no | `{"array":[],"method":"default"}` |  | Surcharge du calendrier des sigmas de débruitage, mutuellement exclusive avec timesteps. Sans surcharge — le comportement par défaut — le planificateur calcule les sigmas à partir de num_inference_steps ; la fourniture d'un calendrier personnalisé rend num_inference_steps sans effet. Une surcharge nécessite que le planificateur prenne en charge l'argument sigmas pour set_sigmas. |
| `sigmas.method` |  | enum (string) | no | `default` | `default`, `array` | Choisissez comment les sigmas sont déterminés : 'default', le paramètre par défaut, utilise les valeurs sigma propres au planificateur. Pour fournir vous-même un calendrier sigma, sélectionnez 'custom' et placez le calendrier dans le champ `array`. |
| `sigmas.array` |  | array of number | no | `[]` |  | Calendrier sigma appliqué lorsque la méthode sélectionnée est 'custom'. |
| `prediction_type` |  | enum (string) | no | `epsilon` | `v_prediction`, `epsilon` | Choisissez le type de prédiction pour générer des images ; sans autre sélection, `epsilon` est utilisé. |
| `rescale_betas_snr_zero` |  | boolean | no | `false` |  | Contrôle l'activation de rescale_betas_snr_zero par l'échantillonneur. |
| `image_format` |  | enum (string) | no | `png` | `jpeg`, `png` | Format de fichier de l'image obtenue. |
| `num_images` | `num_outputs` | integer | no | `1` | 1 – 8 | Définissez le nombre d'images produites par une requête, en permettant un temps de génération plus long pour un lot plus important. |
| `enable_safety_checker` |  | boolean | no | `false` |  | Activation du vérificateur de sécurité ; true active la vérification. |
| `tile_width` |  | integer | no | `4096` | 128 – 4,096 | Définissez la taille de chaque tuile pendant la génération d'images. |
| `tile_height` |  | integer | no | `4096` | 128 – 4,096 | Définissez la taille de chaque tuile pendant la génération d'images. |
| `tile_stride_width` |  | integer | no | `2048` | 64 – 2,048 | Définissez l'espacement entre les positions successives des tuiles pendant la génération d'images. |
| `tile_stride_height` |  | integer | no | `2048` | 64 – 2,048 | Définissez l'espacement entre les positions successives des tuiles pendant la génération d'images. |
| `eta` |  | number | no | `0` | 0 – 1 | Paramètre Eta utilisé lors de la génération d'images. |
| `debug_latents` |  | boolean | no | `false` |  | Enregistre les latents à des fins de débogage lorsque la valeur est true. |
| `debug_per_pass_latents` |  | boolean | no | `false` |  | Activez le débogage à chaque passe en définissant cette valeur sur true, ce qui enregistre les latents de chaque passe. |

File parameters (`image`, `mask`, `ic_light_model_background_image_url`, `ic_light_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
{
  "model_name": "stabilityai/stable-diffusion-xl-base-1.0",
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field"
}
```

A fuller example:

```json
{
  "model_name": "stabilityai/stable-diffusion-xl-base-1.0",
  "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/lora/inpaint?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_name": "stabilityai/stable-diffusion-xl-base-1.0",
    "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/lora/inpaint?wait=20", {
  method: "POST",
  headers,
  body: JSON.stringify({
    "model_name": "stabilityai/stable-diffusion-xl-base-1.0",
    "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 = {
    "model_name": "stabilityai/stable-diffusion-xl-base-1.0",
    "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/lora/inpaint", 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": "lora/inpaint",
      "input": {
        "model_name": "stabilityai/stable-diffusion-xl-base-1.0",
        "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": "lora/inpaint",
  "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": 184,
    "usd": "0.184",
    "charged": 184,
    "refunded": 0
  },
  "input": {
    "model_name": "stabilityai/stable-diffusion-xl-base-1.0",
    "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",
        "content_type": "image/jpeg",
        "file_name": "0-output.jpeg",
        "file_size": 1843200,
        "width": 1024,
        "height": 768
      }
    ],
    "seed": 42,
    "has_nsfw_concepts": [
      false
    ],
    "debug_latents": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_name": "0-output.jpeg",
      "file_size": 1843200
    },
    "debug_per_pass_latents": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.jpeg",
      "content_type": "image/jpeg",
      "file_name": "0-output.jpeg",
      "file_size": 1843200
    }
  },
  "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, content_type, file_name, file_size, width, height} | Informations de fichier pour les images générées. |
| `seed` | integer | Seed de génération d'images, y compris la valeur choisie aléatoirement si l'entrée n'en fournissait pas ; sinon, il reprend la valeur fournie. |
| `has_nsfw_concepts` | array of boolean | Indique si des concepts NSFW apparaissent dans les images générées. |
| `debug_latents` | object {url, content_type, file_name, file_size} \| null | Données latentes stockées à des fins de débogage. |
| `debug_per_pass_latents` | object {url, content_type, file_name, file_size} \| null | Données latentes de chaque passe stockées à des fins de débogage. |

## Related models

- [Stable Diffusion with LoRAs](https://doitong.com/developers/models/lora.md) (`lora`): $0.057 / image
- [Stable Diffusion with LoRAs · Image to Image](https://doitong.com/developers/models/lora/image-to-image.md) (`lora/image-to-image`): $0.264 / 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
- [Qwen Image 3 Edit](https://doitong.com/developers/models/alibaba/qwen-image-3/edit.md) (`alibaba/qwen-image-3/edit`): from $0.04 / image
- [Seedream 5.0 Pro Edit](https://doitong.com/developers/models/bytedance/seedream/v5/pro/edit.md) (`bytedance/seedream/v5/pro/edit`): from $0.0675 / run of output image

## Links

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