Pricing

Every model costs exactly what the model's maker charges for it, in US dollars. You pay from your API balance, which is counted in API credits: 1,000 API credits = $1. The API balance is its own balance, separate from the credits of the Doitong apps. There are no plans, minimums or per-model fees: a call costs its price, debited from the API balance when the request is accepted.

In Russia (doitong.ru, api.doitong.ru, or ?currency=rub) prices are also shown in roubles: the USD price × the USD/RUB rate × 1.3.

Units#

Each model has one billing unit, shown on its page and in GET https://api.doitong.com/v1/models/{model_id}:

Price = quantity × API credits per unit, rounded up to a whole API credit ($0.001), never less than 1. Very cheap units can have a fractional price per unit (0.4 API credits per second); only the total of a call is rounded.

Some models charge a different rate depending on the input: video with sound costs more than without, 4K costs more than 1K, and so on. These rules are listed on each model page. A parameter you leave out counts as its default value, so the price you see for an input is the price you pay.

Exact, measured, estimated and usage prices#

Every price has a mode:

• exact: the price is computed from your input (seconds, images, megapixels, characters, steps, or one flat price per video or call).
• measured: the price follows the files you send: the length of an input video or audio, the size of an input image, the frame rate or frame count of a video. Upscalers, lip sync, video-to-video, transcription and audio tools are priced this way. Before the run the API reads the file's length, resolution and frame rate (the quote does the same), so the quote is exactly what the run charges. The model page says what you pay for ("Price per second of your input video") and its calculator takes your file's numbers. A file that cannot be read is refused with unmeasurable_input and nothing is charged.
• estimate: the model's own cost depends on something the input cannot tell in advance (tokens, compute time). Such a model charges a fixed estimated price per run (per output image when it has an image count), set from the average cost of real runs of that model. You still know the price before you run: the quote is what you pay.
• metered: the model is charged by actual usage, which only the run itself knows: the tokens a language or vision model reads and writes, the seconds of speech a voice model generates, or the model's processing time. See Charged by usage below.

Model pages say "Price per run", "Price per second of your input video" (and similar), "Estimated price per run" or "Charged by usage"; GET https://api.doitong.com/v1/models?mode=measured, ?mode=estimate and ?mode=metered list them.

Charged by usage#

A metered model has a usage price ("$0.01 per 1000 tokens", "$0.002 per second of generated audio", "$0.00111 per second of processing time") and a maximum per run: the most the run can cost, from what your request says (max_tokens, the length of your text, the resolution, the number of outputs) and the model's published limits. It never depends on the content of a file behind a URL. For a model billed by processing time or by the length of a voice session, the maximum is the longest a request may run (15 minutes for images, 30 for audio, 60 for video), so it is far above a typical run. An input whose maximum would be above the model's per-run limit (a very long text) is refused with 422 invalid_input:

1. The quote returns that maximum as credits (with hold and typical, a usual run). When the run starts, the maximum is debited from the API balance, and it is what the balance and your key budget must cover.
2. When the run succeeds, the request is settled to the usage the model reports for it: usage × the usage price, rounded up to a whole API credit. The rest of the maximum is refunded automatically, once, as a refund row of your API balance.
3. A run never costs more than its maximum, even if its usage would. A failed or canceled run is refunded in full, as always.

Most runs cost far less than the maximum; the model page shows "Up to $X per run" for the builder's input and the typical run ("from" in the catalog). For the few models billed by processing time, the usage is the model's processing time (marked approximate).

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

After the run, the request's cost shows what was held and what the usage came to:

{
  "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 is what the run cost. settled.status is pending for the moment between the result and the settlement, and no_usage in the rare case the model reported no usage at all (then the maximum stands as the price).

Quote before you run#

POST https://api.doitong.com/v1/quote/{model_id} takes exactly the body you would send to run and returns the price of that input: the exact price, except for a model charged by usage, where it is the most the run can cost. It needs no key and costs nothing:

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}'

{
  "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": []
}

With a key, the quote also returns balance_credits and balance_usd (your API balance), affordable and key_budget_remaining. Add ?currency=rub for a rub amount.

Price objects#

Every price in the API has the same shape:

• models: 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 and from_rub in Russia or with ?currency=rub;
• requests: cost: { "credits": 560, "usd": "0.56", "charged": 560, "refunded": 0 } (API credits; a metered request adds mode, held, typical and settled, see Charged by usage);
• account: GET https://api.doitong.com/v1/account returns credits (the API balance), balance: { "credits", "usd" } and storage (file storage price, usage and monthly estimate).

Refunds#

• An invalid request (any 4xx before the run starts) is never charged.
• A request that ends failed (including timeout) is refunded in full to the API balance, automatically.
• A request you cancel before it starts is refunded in full. Once the model is generating, a cancel is only a request: if the model finishes, the result is delivered and charged.
• A metered request that succeeds gets back the part of its maximum it did not use.

The request object shows all of it: cost.credits, cost.charged and cost.refunded.

File storage#

Output files are kept on our storage. You choose, in the account or per run (?storage=):

Permanent storage is charged once a day from the API balance: GB kept × the monthly price ÷ days in the month, as ledger rows of kind storage. Fractions of an API credit are carried to the next day, so a month adds up to exactly GB × 100 API credits (1 GB = 1024³ bytes; 10 GB kept for a month cost 1,000 API credits). The balance never goes below zero: when it cannot pay, that day is not charged, you get an email, and you have 30 days to top up before the kept files become temporary and are deleted 7 days later. Details: Files.

Current prices#

These are the featured models. All 1,496 models and their prices are in the model catalog and in GET /models (no key needed).

Top up#

Add money to the API balance at https://doitong.com/developers/dashboard#balance. When the balance is too low, a run answers 402 insufficient_credits with a top_up_url. Each API key can also be capped with its own budget in API credits (see Authentication).