# Preços

Cada modelo custa exatamente o que seu criador cobra por ele, em dólares americanos. Você paga usando seu **saldo da API**,
que é contabilizado em **créditos de API**: **1.000 créditos de API = $ 1**. O saldo da API é próprio e separado
dos créditos dos aplicativos Doitong. Não há planos, mínimos ou taxas por modelo: uma chamada custa seu preço, debitado do
saldo da API quando a requisição é aceita.

Na Rússia (doitong.ru, api.doitong.ru ou `?currency=rub`), os preços também são exibidos em rublos: o preço em USD × a
taxa USD/RUB × 1,3.

## Unidades

Cada modelo tem uma unidade de cobrança, exibida na página dele e em `GET https://api.doitong.com/v1/models/{model_id}`:

| Unidade | Quantidade |
|---|---|
| `second` | Segundos do vídeo ou áudio de saída (`duration`) |
| `image` | Imagens geradas (`num_images`) |
| `megapixel` | Largura × altura da saída, em megapixels (1 MP = 1024 × 1024 pixels) |
| `video` | Um vídeo gerado |
| `request` | Uma chamada |
| `1000_characters` | Caracteres do texto de entrada, por 1000 |
| `step` | Etapas de treinamento |

Preço = quantidade × créditos de API por unidade, arredondado para cima até um crédito de API inteiro ($ 0,001), nunca menos que 1. Unidades muito baratas
podem ter um preço fracionário por unidade (`0.4` créditos de API por segundo); somente o total de uma chamada é arredondado.

Alguns modelos cobram uma tarifa diferente dependendo da entrada: vídeo com som custa mais que sem som, 4K custa mais
que 1K e assim por diante. Essas **regras** são listadas na página de cada modelo. Um parâmetro que você omite conta como seu valor
padrão, portanto o preço exibido para uma entrada é o preço que você paga.

## Preços exatos, medidos, estimados e por uso

Todo preço tem um `mode`:

- `exact`: o preço é calculado a partir da sua entrada (segundos, imagens, megapixels, caracteres, etapas ou um preço fixo
  por vídeo ou chamada).
- `measured`: o preço segue os arquivos enviados: a duração de um vídeo ou áudio de entrada, o tamanho de uma imagem de
  entrada, a taxa de quadros ou a quantidade de quadros de um vídeo. Upscalers, sincronização labial, vídeo para vídeo, transcrição e ferramentas de áudio
  são cobrados dessa forma. Antes da execução, a API lê a duração, a resolução e a taxa de quadros do arquivo (a cotação faz o
  mesmo), portanto a cotação é exatamente o que a execução cobra. A página do modelo informa pelo que você paga ("Preço por segundo do seu
  vídeo de entrada") e a calculadora usa os números do seu arquivo. Um arquivo que não pode ser lido é recusado com
  `unmeasurable_input` e nada é cobrado.
- `estimate`: o custo do próprio modelo depende de algo que a entrada não pode informar antecipadamente (tokens, tempo de processamento).
  Esse modelo cobra um **preço estimado fixo por execução** (por imagem de saída quando há uma quantidade de imagens), definido a partir do
  custo médio de execuções reais desse modelo. Você ainda sabe o preço antes de executar: a cotação é o que você paga.
- `metered`: o modelo é **cobrado pelo uso real**, que somente a própria execução conhece: os tokens que um modelo de linguagem ou
  visão lê e escreve, os segundos de fala que um modelo de voz gera ou o tempo de processamento do modelo.
  Consulte [Cobrança por uso](#metered) abaixo.

As páginas dos modelos informam "Preço por execução", "Preço por segundo do seu vídeo de entrada" (e semelhantes), "Preço estimado por execução" ou
"Cobrança por uso"; `GET https://api.doitong.com/v1/models?mode=measured`, `?mode=estimate` e `?mode=metered` os lista.

## Cobrança por uso

Um modelo `metered` tem um preço por uso ("$0.01 por 1000 tokens", "$0.002 por segundo de áudio gerado", "$0.00111 por
segundo de tempo de processamento") e um **máximo por execução**: o maior valor que a execução pode custar, com base no que sua requisição informa
(`max_tokens`, o comprimento do seu texto, a resolução, a quantidade de saídas) e nos limites publicados do modelo. Isso
nunca depende do conteúdo de um arquivo atrás de uma URL. Para um modelo cobrado pelo tempo de processamento ou pela duração de uma sessão de voz,
o máximo é o maior tempo que uma requisição pode durar (15 minutos para imagens, 30 para áudio, 60 para vídeo), portanto fica muito
acima de uma execução típica. Uma entrada cujo máximo ultrapassaria o limite por execução do modelo (um texto muito longo) é recusada
com `422 invalid_input`:

1. A cotação retorna esse máximo como `credits` (com `hold` e `typical`, uma execução usual). Quando a execução começa, o
   máximo é debitado do saldo da API, e é esse valor que o saldo e o limite da sua chave precisam cobrir.
2. Quando a execução é bem-sucedida, a requisição é ajustada ao uso informado pelo modelo: uso × preço por uso,
   arredondado para cima até um crédito de API inteiro. **O restante do máximo recebe reembolso automaticamente**, uma vez, como uma linha
   `refund` do seu saldo da API.
3. Uma execução nunca custa mais que seu máximo, mesmo que seu uso pudesse ultrapassá-lo. Uma execução que falha ou é cancelada recebe reembolso integral, como
   sempre.

A maioria das execuções custa muito menos que o máximo; a página do modelo mostra "Até $X por execução" para a entrada do criador e a
execução típica ("a partir de" no catálogo). Para os poucos modelos cobrados pelo tempo de processamento, o uso é o tempo de processamento do modelo (marcado como
`approximate`).

```json 200 OK · cotação de um modelo metered
{
  "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"
}
```

Depois da execução, o `cost` da requisição mostra o que foi retido e o valor correspondente ao uso:

```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` é o custo da execução. `settled.status` é `pending` durante o intervalo entre o resultado e o
ajuste, e `no_usage` no caso raro de o modelo não informar nenhum uso (nesse caso, o máximo permanece como preço).

## Consulte o preço antes de executar

`POST https://api.doitong.com/v1/quote/{model_id}` recebe exatamente o corpo que você enviaria para `run` e retorna o preço dessa
entrada: o preço exato, exceto para um modelo [cobrado por uso](#metered), no qual é o máximo que a execução pode custar. Não
precisa de chave e não custa nada:

```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 · cotação
{
  "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": []
}
```

Com uma chave, a cotação também retorna `balance_credits` e `balance_usd` (seu saldo da API), `affordable` e
`key_budget_remaining`. Adicione `?currency=rub` para um valor em `rub`.

> [!TIP]
> **A cotação é a cobrança.** A mesma função calcula ambos, portanto uma execução com esta entrada custa exatamente `credits`.
> A única exceção é um modelo [cobrado por uso](#metered) (`mode: metered`): nesse caso, `credits` é o máximo que a execução pode
> custar, debitado quando ela começa, e a parte não utilizada recebe reembolso depois da execução.

## Objetos de preço

Todo preço na API tem o mesmo formato:

- 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" }` — além de `rub`,
  `rub_display` e `from_rub` na Rússia ou com `?currency=rub`;
- requests: `cost: { "credits": 560, "usd": "0.56", "charged": 560, "refunded": 0 }` (créditos de API; uma requisição metered
  adiciona `mode`, `held`, `typical` e `settled`, consulte [Cobrança por uso](#metered));
- account: `GET https://api.doitong.com/v1/account` retorna `credits` (o saldo da API), `balance: { "credits", "usd" }` e
  `storage` (preço, uso e estimativa mensal do armazenamento de arquivos).

## Reembolsos

- Uma requisição inválida (qualquer `4xx` antes do início da execução) nunca é cobrada.
- Uma requisição que termina como `failed` (incluindo `timeout`) recebe reembolso integral no saldo da API, automaticamente.
- Uma requisição que você cancela antes do início recebe reembolso integral. Depois que o modelo começa a gerar, o cancelamento é apenas uma
  solicitação: se o modelo terminar, o resultado será entregue e cobrado.
- Uma requisição `metered` bem-sucedida recebe de volta a parte do máximo que não utilizou.

O objeto da requisição mostra tudo: `cost.credits`, `cost.charged` e `cost.refunded`.

## Armazenamento de arquivos

Os arquivos de saída são mantidos no nosso armazenamento. Você escolhe, na conta ou por execução (`?storage=`):

| | Mantidos | Preço |
|---|---|---|
| Para sempre (`permanent`, padrão) | Até você excluí-los | 100 créditos de API ($ 0,10) por GB por mês |
| 7 dias (`temporary`) | 7 dias | Grátis |

O armazenamento permanente é cobrado uma vez por dia do saldo da API: GB mantidos × preço mensal ÷ dias do mês, como
linhas do razão de tipo `storage`. Frações de um crédito de API são transportadas para o dia seguinte, portanto um mês totaliza exatamente
GB × 100 créditos de API (1 GB = 1024³ bytes; 10 GB mantidos por um mês custam
1.000 créditos de API). O saldo nunca fica abaixo de zero: quando não puder pagar, esse dia não será cobrado,
você receberá um e-mail e terá 30 dias para fazer uma recarga antes que os arquivos mantidos se tornem temporários e sejam
excluídos 7 dias depois. Detalhes: [Arquivos](https://doitong.com/developers/docs/files#storage).

## Preços atuais

| Modelo | ID | Preço | A partir de |
|---|---|---|---|
| [FLUX.1 \[dev\]](https://doitong.com/developers/models/flux/dev) | `flux/dev` | $ 0,025 / megapixel | $ 0,025 (25 créditos de API) |
| [FLUX.1 \[schnell\]](https://doitong.com/developers/models/flux/schnell) | `flux/schnell` | $ 0,003 / megapixel | $ 0,003 (3 créditos de API) |
| [FLUX.2 \[dev\]](https://doitong.com/developers/models/flux-2) | `flux-2` | $ 0,012 / megapixel | $ 0,012 (12 créditos de API) |
| [FLUX.2 \[pro\]](https://doitong.com/developers/models/flux-2-pro) | `flux-2-pro` | $ 0,015 / megapixel de imagem de saída | $ 0,015 (15 créditos de 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` | a partir de $ 0,008 / imagem | $ 0,008 (8 créditos de API) |
| [Ideogram V4.5](https://doitong.com/developers/models/ideogram/v4.5) | `ideogram/v4.5` | a partir de $ 0,03 / imagem | $ 0,03 (30 créditos de API) |
| [Nano Banana 2](https://doitong.com/developers/models/nano-banana-2) | `nano-banana-2` | a partir de $ 0,06 / imagem | $ 0,06 (60 créditos de API) |
| [Nano Banana Pro](https://doitong.com/developers/models/nano-banana-pro) | `nano-banana-pro` | a partir de $ 0,15 / imagem | $ 0,15 (150 créditos de 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` | a partir de $ 0,04 / imagem | $ 0,04 (40 créditos de 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 / imagem | $ 0,035 (35 créditos de 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` | a partir de $ 0,068 | $ 0,068 (68 créditos de API) |
| [FLUX.1 Kontext \[pro\]](https://doitong.com/developers/models/flux-pro/kontext) | `flux-pro/kontext` | $ 0,04 / imagem | $ 0,04 (40 créditos de API) |
| [Nano Banana 2 Edit](https://doitong.com/developers/models/nano-banana-2/edit) | `nano-banana-2/edit` | a partir de $ 0,06 / imagem | $ 0,06 (60 créditos de API) |
| [Nano Banana Pro Edit](https://doitong.com/developers/models/nano-banana-pro/edit) | `nano-banana-pro/edit` | a partir de $ 0,15 / imagem | $ 0,15 (150 créditos de API) |
| [Qwen Image 3 Edit](https://doitong.com/developers/models/alibaba/qwen-image-3/edit) | `alibaba/qwen-image-3/edit` | a partir de $ 0,04 / imagem | $ 0,04 (40 créditos de 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` | a partir de $ 0,0425 / segundo de vídeo de saída | $ 0,043 (43 créditos de 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` | a partir de $ 0,08 / segundo | $ 0,48 (480 créditos de 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` | a partir de $ 0,112 / segundo | $ 0,56 (560 créditos de 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` | a partir de $ 0,12 / segundo | $ 0,72 (720 créditos de API) |
| [MiniMax H3 Text to Video](https://doitong.com/developers/models/minimax/h3/text-to-video) | `minimax/h3/text-to-video` | a partir de $ 0,05 / segundo | $ 0,25 (250 créditos de 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` | a partir de $ 0,113 / segundo | $ 0,452 (452 créditos de 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` | a partir de $ 0,141 / segundo | $ 0,564 (564 créditos de API) |
| [Veo 3.1](https://doitong.com/developers/models/veo3.1) | `veo3.1` | a partir de $ 0,20 / segundo | $ 1,60 (1.600 créditos de API) |
| [Veo 3.1 Fast](https://doitong.com/developers/models/veo3.1/fast) | `veo3.1/fast` | a partir de $ 0,10 / segundo | $ 0,80 (800 créditos de 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` | a partir de $ 0,05 / segundo | $ 0,25 (250 créditos de 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` | a partir de $ 0,0425 / segundo de vídeo de saída | $ 0,043 (43 créditos de 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` | a partir de $ 0,082 / segundo | $ 0,492 (492 créditos de 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` | a partir de $ 0,112 / segundo | $ 0,56 (560 créditos de 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` | a partir de $ 0,12 / segundo | $ 0,72 (720 créditos de API) |
| [MiniMax H3 Image to Video](https://doitong.com/developers/models/minimax/h3/image-to-video) | `minimax/h3/image-to-video` | a partir de $ 0,05 / segundo | $ 0,25 (250 créditos de 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` | a partir de $ 0,113 / segundo | $ 0,452 (452 créditos de 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` | a partir de $ 0,141 / segundo | $ 0,564 (564 créditos de 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` | a partir de $ 0,10 / segundo | $ 0,80 (800 créditos de API) |
| [Veo 3.1 Image to Video](https://doitong.com/developers/models/veo3.1/image-to-video) | `veo3.1/image-to-video` | a partir de $ 0,20 / segundo | $ 1,60 (1.600 créditos de 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` | a partir de $ 0,05 / segundo | $ 0,25 (250 créditos de 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` | a partir de $ 0,113 / segundo | $ 0,452 (452 créditos de 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` | a partir de $ 0,141 / segundo | $ 0,564 (564 créditos de 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 / segundo de áudio de entrada | $ 0,115 (115 créditos de API) |
| [Sync Lipsync 3](https://doitong.com/developers/models/sync-lipsync/v3) | `sync-lipsync/v3` | $ 8,00 / minuto de vídeo de saída | $ 8,00 (8.000 créditos de API) |
| [VEED Fabric 1.0](https://doitong.com/developers/models/veed/fabric-1.0) | `veed/fabric-1.0` | a partir de $ 0,08 / segundo de áudio de entrada | $ 0,08 (80 créditos de API) |
| [Topaz Image Upscale](https://doitong.com/developers/models/topaz/upscale/image/precision) | `topaz/upscale/image/precision` | $ 0,08 / 24 megapixels de imagem de saída | $ 0,08 (80 créditos de API) |
| [Topaz Video Upscale](https://doitong.com/developers/models/topaz/upscale/video/precision) | `topaz/upscale/video/precision` | a partir de $ 0,00667 / segundo de vídeo de entrada | $ 0,10 (100 créditos de API) |
| [Bria RMBG 2.0](https://doitong.com/developers/models/bria/background/remove) | `bria/background/remove` | a partir de $ 0,018 | $ 0,018 (18 créditos de API) |
| [Eleven v4 Text to Speech](https://doitong.com/developers/models/elevenlabs/tts/eleven-v4) | `elevenlabs/tts/eleven-v4` | $ 0,08 / 1000 caracteres | $ 0,08 (80 créditos de API) |
| [MiniMax Speech 2.8 HD](https://doitong.com/developers/models/minimax/speech-2.8-hd) | `minimax/speech-2.8-hd` | $ 0,10 / 1000 caracteres | $ 0,10 (100 créditos de API) |
| [MiniMax Music 3](https://doitong.com/developers/models/minimax/music-3) | `minimax/music-3` | $ 0,002 / segundo | $ 0,12 (120 créditos de API) |
| [MMAudio V2](https://doitong.com/developers/models/mmaudio-v2) | `mmaudio-v2` | $ 0,001 / segundo | $ 0,008 (8 créditos de API) |

Estes são os modelos em destaque. Todos os 1.496 modelos e seus preços estão no [catálogo de modelos](https://doitong.com/developers/models) e em `GET /models` (nenhuma chave necessária).

## Fazer uma recarga

Adicione dinheiro ao saldo da API em [https://doitong.com/developers/dashboard#balance](https://doitong.com/developers/dashboard#balance). Quando o saldo estiver baixo demais, uma execução responderá
`402 insufficient_credits` com um `top_up_url`. Cada chave de API também pode ter seu próprio limite em créditos de API
(consulte [Autenticação](https://doitong.com/developers/docs/authentication#credit-budgets)).
