# Tarification

Chaque modèle coûte exactement ce que son créateur facture, en dollars américains. Vous payez à partir de votre **solde API**,
qui est compté en **crédits API** : **1 000 crédits API = 1 $**. Le solde API est distinct de celui des applications Doitong. Il n’y a
ni forfait, ni minimum, ni frais par modèle : un appel coûte son prix, débité du solde API lorsque la requête est acceptée.

En Russie (doitong.ru, api.doitong.ru ou `?currency=rub`), les prix sont aussi affichés en roubles : le prix USD × le
taux USD/RUB × 1,3.

## Unités

Chaque modèle possède une unité de facturation, affichée sur sa page et dans `GET https://api.doitong.com/v1/models/{model_id}` :

| Unité | Quantité |
|---|---|
| `second` | Secondes de vidéo ou d’audio en sortie (`duration`) |
| `image` | Images générées (`num_images`) |
| `megapixel` | Largeur × hauteur de la sortie, en mégapixels (1 MP = 1024 × 1024 pixels) |
| `video` | Une vidéo générée |
| `request` | Un appel |
| `1000_characters` | Caractères du texte d’entrée, par 1000 |
| `step` | Étapes d’entraînement |

Prix = quantité × crédits API par unité, arrondi à la hausse au crédit API entier (0,001 $), jamais inférieur à 1. Les unités très peu coûteuses
peuvent avoir un prix fractionnaire par unité (`0.4` crédits API par seconde); seul le total d’un appel est arrondi.

Certains modèles appliquent un tarif différent selon l’entrée : une vidéo avec son coûte plus cher que sans son, la 4K coûte plus
cher que la 1K, etc. Ces **règles** sont indiquées sur chaque page de modèle. Un paramètre omis prend sa valeur par défaut,
donc le prix affiché pour une entrée est celui que vous payez.

## Prix exacts, mesurés, estimés et selon l’utilisation

Chaque prix possède un `mode` :

- `exact` : le prix est calculé à partir de votre entrée (secondes, images, mégapixels, caractères, étapes, ou un prix fixe par vidéo ou appel).
- `measured` : le prix dépend des fichiers envoyés : durée d’une vidéo ou d’un audio d’entrée, taille d’une image d’entrée,
  fréquence d’images ou nombre d’images d’une vidéo. Les outils d’agrandissement, de synchronisation labiale, de vidéo à vidéo, de transcription et audio
  sont tarifés ainsi. Avant l’exécution, l’API lit la durée, la résolution et la fréquence d’images du fichier (le devis fait de même),
  donc le devis correspond exactement à ce que l’exécution facture. La page du modèle indique ce qui est facturé (« Price per second of your
  input vidéo ») et son calculateur utilise les valeurs de votre fichier. Un fichier illisible est refusé avec
  `unmeasurable_input` et aucun frais n’est facturé.
- `estimate` : le coût propre au modèle dépend de quelque chose que l’entrée ne permet pas de connaître à l’avance (jetons, temps de calcul).
  Un tel modèle facture un **prix estimé fixe par exécution** (par image de sortie lorsqu’il possède un nombre d’images), établi à partir du
  coût moyen des exécutions réelles de ce modèle. Vous connaissez tout de même le prix avant l’exécution : le devis est le montant payé.
- `metered` : le modèle est **facturé selon l’utilisation réelle**, que seule l’exécution connaît : les jetons lus et écrits par un modèle
  de langage ou de vision, les secondes de parole générées par un modèle vocal ou le temps de traitement du modèle.
  Voir [Facturation selon l’utilisation](#metered) ci-dessous.

Les pages des modèles indiquent « Price per run », « Price per second of your input vidéo » (et équivalents), « Estimated price per run » ou
« Charged by usage »; `GET https://api.doitong.com/v1/models?mode=measured`, `?mode=estimate` et `?mode=metered` les répertorient.

## Facturation selon l’utilisation

Un modèle `metered` possède un prix d’utilisation (« $0.01 par 1000 jetons », « $0.002 par seconde d’audio généré », « $0.00111 par
seconde de temps de traitement ») et un **maximum par exécution** : le montant maximal de l’exécution, selon ce que votre requête indique
(`max_tokens`, la longueur de votre texte, la résolution, le nombre de sorties) et les limites publiées du modèle. Il ne dépend
jamais du contenu d’un fichier derrière une URL. Pour un modèle facturé selon le temps de traitement ou la durée d’une session vocale,
le maximum correspond à la durée maximale d’une requête (15 minutes pour les images, 30 pour l’audio, 60 pour la vidéo), donc il est bien
supérieur à celui d’une exécution typique. Une entrée dont le maximum dépasserait la limite par exécution du modèle (un très long texte) est refusée
avec `422 invalid_input` :

1. Le devis renvoie ce maximum sous `credits` (avec `hold` et `typical`, pour une exécution habituelle). Au démarrage de l’exécution, le
   maximum est débité du solde API; c’est le montant que le solde et le budget de votre clé doivent couvrir.
2. Lorsque l’exécution réussit, la requête est réglée selon l’utilisation déclarée par le modèle : utilisation × prix d’utilisation,
   arrondi à la hausse au crédit API entier. **Le reste du maximum est remboursé automatiquement**, une fois, sous forme d’une ligne `refund`
   dans votre solde API.
3. Une exécution ne coûte jamais plus que son maximum, même si son utilisation le dépasserait. Une exécution échouée ou annulée est entièrement remboursée,
   comme toujours.

La plupart des exécutions coûtent beaucoup moins que le maximum; la page du modèle affiche « Up to $X per run » pour l’entrée du générateur et l’exécution
typique (« from » dans le catalogue). Pour les quelques modèles facturés au temps de traitement, l’utilisation correspond au temps de traitement du modèle (marqué
`approximate`).

```json 200 OK · devis d’un modèle mesuré
{
  "object": "quote",
  "credits": 621,
  "usd": "0.621",
  "mode": "metered",
  "label": "Charged by usage",
  "hold": { "credits": 621, "usd": "0.621" },
  "typical": { "credits": 10, "usd": "0.01" },
  "settlement": "usage",
  "display": "$0.01 / 1000 tokens",
  "breakdown": "up to 62.035 × 1000 tokens × $0.01"
}
```

Après l’exécution, le `cost` de la requête indique le montant retenu et celui correspondant à l’utilisation :

```json
{
  "cost": { "credits": 621, "usd": "0.621", "charged": 621, "refunded": 611, "mode": "metered", "held": 621,
            "typical": 10, "settled": { "status": "settled", "credits": 10, "usd": "0.01", "quantity": 1,
            "unit": "1000_tokens", "unit_usd": "0.01", "source": "billed_usage", "approximate": false } }
}
```

`charged − refunded` correspond au coût de l’exécution. `settled.status` vaut `pending` pendant l’intervalle entre le résultat et le règlement, et
`no_usage` dans le rare cas où le modèle n’a déclaré aucune utilisation (le maximum constitue alors le prix).

## Obtenir un devis avant l’exécution

`POST https://api.doitong.com/v1/quote/{model_id}` prend exactement le corps que vous enverriez à `run` et renvoie le prix de cette entrée : le prix exact,
à l’exception d’un modèle [facturé selon l’utilisation](#metered), pour lequel il s’agit du montant maximal de l’exécution. Aucune clé n’est requise
et rien n’est facturé :

```bash
curl -X POST "https://api.doitong.com/v1/quote/flux/schnell" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A lighthouse at dusk", "num_images": 2}'
```

```json 200 OK · devis
{
  "object": "quote",
  "model": "flux/schnell",
  "credits": 6,
  "usd": "0.006",
  "unit": "megapixel",
  "quantity": 2,
  "unit_credits": 3,
  "mode": "exact",
  "label": "Price per run",
  "display": "$0.003 / megapixel",
  "breakdown": "2 MP (2 images) × 3 API credits",
  "input": { "prompt": "A lighthouse at dusk", "num_images": 2 },
  "warnings": []
}
```

Avec une clé, le devis renvoie aussi `balance_credits` et `balance_usd` (votre solde API), `affordable` et
`key_budget_remaining`. Ajoutez `?currency=rub` pour obtenir un montant en `rub`.

> [!TIP]
> **Le devis correspond au montant facturé.** La même fonction calcule les deux, donc une exécution avec cette entrée coûte exactement `credits`.
> La seule exception est un modèle [facturé selon l’utilisation](#metered) (`mode: metered`) : dans ce cas, `credits` est le montant maximal que l’exécution peut
> coûter, débité à son démarrage; la partie inutilisée est remboursée après l’exécution.

## Objets de prix

Chaque prix dans l’API possède la même structure :

- modèles : `price: { "credits": 112, "usd": "0.112", "unit": "second", "display": "$0.112 / second",
  "credits_display": "112 API credits / second", "from_credits": 560, "from_usd": "0.56", "mode": "exact" }` — plus `rub`,
  `rub_display` et `from_rub` en Russie ou avec `?currency=rub`;
- requêtes : `cost: { "credits": 560, "usd": "0.56", "charged": 560, "refunded": 0 }` (crédits API; une requête mesurée
  ajoute `mode`, `held`, `typical` et `settled`, voir [Facturation selon l’utilisation](#metered));
- compte : `GET https://api.doitong.com/v1/account` renvoie `credits` (le solde API), `balance: { "credits", "usd" }` et
  `storage` (prix, utilisation et estimation mensuelle du stockage de fichiers).

## Remboursements

- Une requête invalide (tout `4xx` avant le début de l’exécution) n’est jamais facturée.
- Une requête qui se termine par `failed` (y compris `timeout`) est entièrement remboursée au solde API, automatiquement.
- Une requête que vous annulez avant son démarrage est entièrement remboursée. Une fois que le modèle génère, l’annulation n’est qu’une
  demande : si le modèle termine, le résultat est livré et facturé.
- Une requête `metered` qui réussit récupère la partie de son maximum qu’elle n’a pas utilisée.

L’objet de requête affiche tous ces montants : `cost.credits`, `cost.charged` et `cost.refunded`.

## Stockage des fichiers

Les fichiers de sortie sont conservés dans notre stockage. Vous choisissez la durée dans le compte ou par exécution (`?storage=`) :

| | Conservation | Prix |
|---|---|---|
| Indéfiniment (`permanent`, par défaut) | Jusqu’à leur suppression | 100 crédits API (0,10 $) par Go par mois |
| 7 jours (`temporary`) | 7 jours | Gratuit |

Le stockage permanent est facturé une fois par jour à partir du solde API : Go conservés × prix mensuel ÷ nombre de jours du mois, sous forme de lignes
comptables de type `storage`. Les fractions de crédit API sont reportées au jour suivant, de sorte qu’un mois totalise exactement
Go × 100 crédits API (1 Go = 1024³ octets; 10 Go conservés pendant un mois coûtent
1 000 crédits API). Le solde ne devient jamais négatif : lorsqu’il ne peut pas payer, la journée n’est pas facturée,
vous recevez un courriel et vous disposez de 30 jours pour recharger avant que les fichiers conservés deviennent temporaires et soient
supprimés 7 jours plus tard. Détails : [Fichiers](https://doitong.com/developers/docs/files#storage).

## Prix actuels

| Modèle | ID | Prix | À partir de |
|---|---|---|---|
| [FLUX.1 \[dev\]](https://doitong.com/developers/models/flux/dev) | `flux/dev` | 0,025 $ / mégapixel | 0,025 $ (25 crédits API) |
| [FLUX.1 \[schnell\]](https://doitong.com/developers/models/flux/schnell) | `flux/schnell` | 0,003 $ / mégapixel | 0,003 $ (3 crédits API) |
| [FLUX.2 \[dev\]](https://doitong.com/developers/models/flux-2) | `flux-2` | 0,012 $ / mégapixel | 0,012 $ (12 crédits API) |
| [FLUX.2 \[pro\]](https://doitong.com/developers/models/flux-2-pro) | `flux-2-pro` | 0,015 $ / mégapixel d’image de sortie | 0,015 $ (15 crédits API) |
| [GPT Image 2.5 Text to Image](https://doitong.com/developers/models/openai/gpt-image-2.5/flare/text-to-image) | `openai/gpt-image-2.5/flare/text-to-image` | à partir de 0,008 $ / image | 0,008 $ (8 crédits API) |
| [Ideogram V4.5](https://doitong.com/developers/models/ideogram/v4.5) | `ideogram/v4.5` | à partir de 0,03 $ / image | 0,03 $ (30 crédits API) |
| [Nano Banana 2](https://doitong.com/developers/models/nano-banana-2) | `nano-banana-2` | à partir de 0,06 $ / image | 0,06 $ (60 crédits API) |
| [Nano Banana Pro](https://doitong.com/developers/models/nano-banana-pro) | `nano-banana-pro` | à partir de 0,15 $ / image | 0,15 $ (150 crédits API) |
| [Qwen Image 3 Text to Image](https://doitong.com/developers/models/alibaba/qwen-image-3/text-to-image) | `alibaba/qwen-image-3/text-to-image` | à partir de 0,04 $ / image | 0,04 $ (40 crédits API) |
| [Recraft V4.1 Text to Image](https://doitong.com/developers/models/recraft/v4.1/text-to-image) | `recraft/v4.1/text-to-image` | 0,035 $ / image | 0,035 $ (35 crédits API) |
| [Seedream 5.0 Pro Text to Image](https://doitong.com/developers/models/bytedance/seedream/v5/pro/text-to-image) | `bytedance/seedream/v5/pro/text-to-image` | à partir de 0,068 $ | 0,068 $ (68 crédits API) |
| [FLUX.1 Kontext \[pro\]](https://doitong.com/developers/models/flux-pro/kontext) | `flux-pro/kontext` | 0,04 $ / image | 0,04 $ (40 crédits API) |
| [Nano Banana 2 Edit](https://doitong.com/developers/models/nano-banana-2/edit) | `nano-banana-2/edit` | à partir de 0,06 $ / image | 0,06 $ (60 crédits API) |
| [Nano Banana Pro Edit](https://doitong.com/developers/models/nano-banana-pro/edit) | `nano-banana-pro/edit` | à partir de 0,15 $ / image | 0,15 $ (150 crédits API) |
| [Qwen Image 3 Edit](https://doitong.com/developers/models/alibaba/qwen-image-3/edit) | `alibaba/qwen-image-3/edit` | à partir de 0,04 $ / image | 0,04 $ (40 crédits API) |
| [FLUX 3 Max Text to Video](https://doitong.com/developers/models/blackforestlabs/flux-3-max/text-to-video) | `blackforestlabs/flux-3-max/text-to-video` | à partir de 0,0425 $ / seconde de vidéo de sortie | 0,043 $ (43 crédits API) |
| [Grok Imagine Video 1.5 Text to Video](https://doitong.com/developers/models/xai/grok-imagine-video/v1.5/text-to-video) | `xai/grok-imagine-video/v1.5/text-to-video` | à partir de 0,08 $ / seconde | 0,48 $ (480 crédits API) |
| [Kling 3.0 Pro Text to Video](https://doitong.com/developers/models/kling-video/v3/pro/text-to-video) | `kling-video/v3/pro/text-to-video` | à partir de 0,112 $ / seconde | 0,56 $ (560 crédits API) |
| [LTX 2.5 Pro Text to Video](https://doitong.com/developers/models/lightricks/ltx-2.5/text-to-video/pro) | `lightricks/ltx-2.5/text-to-video/pro` | à partir de 0,12 $ / seconde | 0,72 $ (720 crédits API) |
| [MiniMax H3 Text to Video](https://doitong.com/developers/models/minimax/h3/text-to-video) | `minimax/h3/text-to-video` | à partir de 0,05 $ / seconde | 0,25 $ (250 crédits API) |
| [Seedance 2.0 Fast Text to Video](https://doitong.com/developers/models/bytedance/seedance-2.0/fast/text-to-video) | `bytedance/seedance-2.0/fast/text-to-video` | à partir de 0,113 $ / seconde | 0,452 $ (452 crédits API) |
| [Seedance 2.0 Text to Video](https://doitong.com/developers/models/bytedance/seedance-2.0/text-to-video) | `bytedance/seedance-2.0/text-to-video` | à partir de 0,141 $ / seconde | 0,564 $ (564 crédits API) |
| [Veo 3.1](https://doitong.com/developers/models/veo3.1) | `veo3.1` | à partir de 0,20 $ / seconde | 1,60 $ (1 600 crédits API) |
| [Veo 3.1 Fast](https://doitong.com/developers/models/veo3.1/fast) | `veo3.1/fast` | à partir de 0,10 $ / seconde | 0,80 $ (800 crédits API) |
| [Wan 3.0 Text to Video](https://doitong.com/developers/models/alibaba/wan-3.0/text-to-video) | `alibaba/wan-3.0/text-to-video` | à partir de 0,05 $ / seconde | 0,25 $ (250 crédits API) |
| [FLUX 3 Max Image to Video](https://doitong.com/developers/models/blackforestlabs/flux-3-max/image-to-video) | `blackforestlabs/flux-3-max/image-to-video` | à partir de 0,0425 $ / seconde de vidéo de sortie | 0,043 $ (43 crédits API) |
| [Grok Imagine Video 1.5 Image to Video](https://doitong.com/developers/models/xai/grok-imagine-video/v1.5/image-to-video) | `xai/grok-imagine-video/v1.5/image-to-video` | à partir de 0,082 $ / seconde | 0,492 $ (492 crédits API) |
| [Kling 3.0 Pro Image to Video](https://doitong.com/developers/models/kling-video/v3/pro/image-to-video) | `kling-video/v3/pro/image-to-video` | à partir de 0,112 $ / seconde | 0,56 $ (560 crédits API) |
| [LTX 2.5 Pro Image to Video](https://doitong.com/developers/models/lightricks/ltx-2.5/image-to-video/pro) | `lightricks/ltx-2.5/image-to-video/pro` | à partir de 0,12 $ / seconde | 0,72 $ (720 crédits API) |
| [MiniMax H3 Image to Video](https://doitong.com/developers/models/minimax/h3/image-to-video) | `minimax/h3/image-to-video` | à partir de 0,05 $ / seconde | 0,25 $ (250 crédits API) |
| [Seedance 2.0 Fast Image to Video](https://doitong.com/developers/models/bytedance/seedance-2.0/fast/image-to-video) | `bytedance/seedance-2.0/fast/image-to-video` | à partir de 0,113 $ / seconde | 0,452 $ (452 crédits API) |
| [Seedance 2.0 Image to Video](https://doitong.com/developers/models/bytedance/seedance-2.0/image-to-video) | `bytedance/seedance-2.0/image-to-video` | à partir de 0,141 $ / seconde | 0,564 $ (564 crédits API) |
| [Veo 3.1 Fast Image to Video](https://doitong.com/developers/models/veo3.1/fast/image-to-video) | `veo3.1/fast/image-to-video` | à partir de 0,10 $ / seconde | 0,80 $ (800 crédits API) |
| [Veo 3.1 Image to Video](https://doitong.com/developers/models/veo3.1/image-to-video) | `veo3.1/image-to-video` | à partir de 0,20 $ / seconde | 1,60 $ (1 600 crédits API) |
| [Wan 3.0 Image to Video](https://doitong.com/developers/models/alibaba/wan-3.0/image-to-video) | `alibaba/wan-3.0/image-to-video` | à partir de 0,05 $ / seconde | 0,25 $ (250 crédits API) |
| [Seedance 2.0 Fast Reference to Video](https://doitong.com/developers/models/bytedance/seedance-2.0/fast/reference-to-video) | `bytedance/seedance-2.0/fast/reference-to-video` | à partir de 0,113 $ / seconde | 0,452 $ (452 crédits API) |
| [Seedance 2.0 Reference to Video](https://doitong.com/developers/models/bytedance/seedance-2.0/reference-to-video) | `bytedance/seedance-2.0/reference-to-video` | à partir de 0,141 $ / seconde | 0,564 $ (564 crédits API) |
| [Kling AI Avatar 2.0 Pro](https://doitong.com/developers/models/kling-video/ai-avatar/v2/pro) | `kling-video/ai-avatar/v2/pro` | 0,115 $ / seconde d’audio d’entrée | 0,115 $ (115 crédits API) |
| [Sync Lipsync 3](https://doitong.com/developers/models/sync-lipsync/v3) | `sync-lipsync/v3` | 8,00 $ / minute de vidéo de sortie | 8,00 $ (8 000 crédits API) |
| [VEED Fabric 1.0](https://doitong.com/developers/models/veed/fabric-1.0) | `veed/fabric-1.0` | à partir de 0,08 $ / seconde d’audio d’entrée | 0,08 $ (80 crédits API) |
| [Topaz Image Upscale](https://doitong.com/developers/models/topaz/upscale/image/precision) | `topaz/upscale/image/precision` | 0,08 $ / 24 mégapixels d’image de sortie | 0,08 $ (80 crédits API) |
| [Topaz Video Upscale](https://doitong.com/developers/models/topaz/upscale/video/precision) | `topaz/upscale/video/precision` | à partir de 0,00667 $ / seconde de vidéo d’entrée | 0,10 $ (100 crédits API) |
| [Bria RMBG 2.0](https://doitong.com/developers/models/bria/background/remove) | `bria/background/remove` | à partir de 0,018 $ | 0,018 $ (18 crédits API) |
| [Eleven v4 Text to Speech](https://doitong.com/developers/models/elevenlabs/tts/eleven-v4) | `elevenlabs/tts/eleven-v4` | 0,08 $ / 1000 caractères | 0,08 $ (80 crédits API) |
| [MiniMax Speech 2.8 HD](https://doitong.com/developers/models/minimax/speech-2.8-hd) | `minimax/speech-2.8-hd` | 0,10 $ / 1000 caractères | 0,10 $ (100 crédits API) |
| [MiniMax Music 3](https://doitong.com/developers/models/minimax/music-3) | `minimax/music-3` | 0,002 $ / seconde | 0,12 $ (120 crédits API) |
| [MMAudio V2](https://doitong.com/developers/models/mmaudio-v2) | `mmaudio-v2` | 0,001 $ / seconde | 0,008 $ (8 crédits API) |

Voici les modèles en vedette. Les 1 496 modèles et leurs prix se trouvent dans le [catalogue de modèles](https://doitong.com/developers/models) et dans `GET /models` (aucune clé requise).

## Recharger

Ajoutez des fonds au solde API à [https://doitong.com/developers/dashboard#balance](https://doitong.com/developers/dashboard#balance). Lorsque le solde est insuffisant, une exécution répond
`402 insufficient_credits` avec un `top_up_url`. Chaque clé API peut aussi être limitée par son propre budget en crédits API
(voir [Authentification](https://doitong.com/developers/docs/authentication#credit-budgets)).
