Precificação multimodal: o que imagens, áudio e vídeo realmente cobram

Um transformer recebe uma sequência de vetores. Ele não tem opinião sobre de onde eles vieram. O Capítulo 8 o alimentou com embeddings buscados a partir de um ID de token; nada na arquitetura exige essa busca.

Então: corte a imagem em quadrados fixos, achate cada quadrado em uma lista de números e passe cada lista por uma camada linear aprendida para obter um vetor com a largura do modelo. Um patch de 32 × 32 pixels coloridos tem $32 \times 32 \times 3 = 3072$ números; a projeção $E \in \mathbb{R}^{d \times 3072}$ o transforma em um vetor $d$-dimensional, exatamente o formato em que um token de texto chega. É só isso, e está no artigo cujo título já diz: uma imagem vale 16 × 16 palavras.¹ Adicione uma codificação posicional para o modelo saber qual quadrado estava onde, intercale os resultados com os embeddings de texto, e a sequência lida pelo modelo é parte imagem e parte frase.

Três artigos transformaram isso em produto. CLIP treinou um codificador de imagem e um codificador de texto para concordarem, em quatrocentos milhões de pares coletados da web, e foi ali que a ideia de pixels e palavras compartilharem um espaço deixou de ser hipótese.² Flamingo acoplou um codificador de visão congelado a um modelo de linguagem congelado com algumas camadas de ponte treinadas.³ LLaVA mostrou que a ponte podia ser uma única projeção linear e que o seguimento de instruções podia ser ensinado com dados gerados, por isso todo modelo aberto de visão-linguagem desde então parece mais ou menos igual.⁴

A consequência para sua fatura é imediata e nada glamourosa: os patches são posições na sequência, portanto são input tokens, portanto você paga por eles na taxa de entrada. Quantos são é aritmética, e cada fornecedor faz de um jeito.

Cada regra abaixo é implementada a partir da própria documentação do fornecedor e conferida contra os exemplos trabalhados nessa mesma documentação.

A OpenAI cobre a imagem com patches de 32 × 32 e multiplica a contagem por um fator por modelo. Se a contagem de patches excede o orçamento desse modelo e nível de detalhe, a imagem é reduzida até caber:

A Anthropic a cobre com patches de 28 × 28, um visual token cada, e limita tanto a borda maior quanto a contagem de token — 1.568 pixels e 1.568 tokens em modelos de faixa padrão, 2.576 e 4.784 na faixa de alta resolução. Imagens grandes demais são reduzidas ao maior tamanho que caiba nos dois limites.⁵

O Google não conta pixels. Uma imagem com ambos os lados em até 384 pixels custa uma taxa fixa de 258 tokens. Qualquer coisa maior é cortada em tiles de 258 tokens cada, e a grade de tiles vem de uma unidade de corte de $\lfloor \min(w,h) / 1.5 \rfloor$.⁶

export function openaiImageTokens(
  w: number, h: number,
  { maxDim, patchBudget, multiplier }: { maxDim: number; patchBudget: number; multiplier: number },
) {
  const fit = Math.min(1, maxDim / Math.max(w, h));      // never enlarges
  w = Math.floor(w * fit); h = Math.floor(h * fit);
  let patches = Math.ceil(w / 32) * Math.ceil(h / 32);   
  if (patches > patchBudget) {
    const s = Math.sqrt((32 * 32 * patchBudget) / (w * h));
    const adj = s * Math.min(
      Math.floor((w * s) / 32) / ((w * s) / 32),
      Math.floor((h * s) / 32) / ((h * s) / 32));
    patches = Math.ceil(Math.floor(w * adj) / 32) * Math.ceil(Math.floor(h * adj) / 32);
  }
  return Math.ceil(patches * multiplier);                
}

export function anthropicVisualTokens(
  w: number, h: number,
  { maxLongEdge, maxTokens }: { maxLongEdge: number; maxTokens: number },
) {
  const tok = (a: number, b: number) => Math.ceil(a / 28) * Math.ceil(b / 28);
  const long = Math.max(w, h), short = Math.min(w, h);
  for (let L = Math.min(long, maxLongEdge); L >= 1; L--) {     
    const t = tok(L, Math.round((short * L) / long));
    if (t <= maxTokens) return t;                              
  }
  return 0;
}

export function geminiImageTokens(w: number, h: number) {
  if (w <= 384 && h <= 384) return 258;
  const crop = Math.floor(Math.min(w, h) / 1.5);               
  return Math.ceil(w / crop) * Math.ceil(h / crop) * 258;      
}

Execute cada uma contra os números que o próprio fornecedor imprime:

OpenAI, gpt-5.4 at detail:high (2048 px, 2,500 patches, 1.2x)
  1024x1024 -> 1024 patches -> 1229 tokens   doc says 1229   MATCH
  2048x2048 -> 2500 patches -> 3000 tokens   doc says 3000   MATCH

Anthropic, the published table (one tier per row shown)
  200x200    std   64 @ 200x200     doc   64, not resized    OK
  1000x1000  std 1296 @ 1000x1000   doc 1296, not resized    OK
  1092x1092  std 1521 @ 1092x1092   doc 1521, not resized    OK
  1920x1080  std 1560 @ 1456x819    doc 1560, 1456x819       OK
  2000x1500  std 1564 @ 1269x952    doc 1564, 1269x952       OK
  3840x2160  hi  4784 @ 2576x1449   doc 4784, 2576x1449      OK

Google, the worked example
  960x540 -> crop 360 -> 3 x 2 = 6 tiles     doc says 6      MATCH

Nove concordâncias são impressas; a execução completa confere quinze, já que a tabela da Anthropic dá as duas faixas para todos os seis tamanhos. As regras agora são suas para rodar em qualquer fotografia que você tiver, e esse é o ponto: estas são as únicas três funções deste capítulo que você não consegue tirar de uma página de preços.

Passe a mesma fotografia 4:3 pelas três regras em seis tamanhos:

Leia a última coluna de cima para baixo. Depois que a imagem passa de 384 pixels, o número nunca muda de novo, e isso não é coincidência nem limite. Substitua a unidade de corte de volta na fórmula de tiles, para uma imagem pelo menos tão larga quanto alta:

O tamanho cancela. Os image tokens do Google dependem da proporção de aspecto e de nada mais. Uma fotografia 4:3 tem quatro tiles seja ela uma miniatura ou um pôster. Esse único fato algébrico é a explicação inteira do zero na tabela de economia acima, e nenhuma página de preços em lugar nenhum o afirma.

As outras duas colunas impõem limites, em alturas diferentes e por motivos diferentes — Anthropic em um teto declarado de token, OpenAI em um orçamento de patches depois de um limite de pixels —, e é por isso que as três curvas se cruzam em tamanhos diferentes.

Agora quebre a regra. A maneira óbvia de gastar menos em um modelo de visão é pedir menos detalhe, então envie detail: "low":

1600x1200   low = 2280   high = 2280   ratio 1.00
3200x2400   low = 3687   high = 2942   ratio 1.25

Pedir menos detalhe custou 25 % mais. Isso não é bug, e a OpenAI diz isso em uma linha da tabela de dimensionamento: nessa família de modelos, low usa um limite de 2048 pixels com um orçamento de 6.144 patches, enquanto high usa o mesmo limite de pixels com um orçamento de 2.500 patches, «portanto pode usar mais tokens que high».⁷ A palavra low nomeia uma configuração de fidelidade, não um preço: em duas das cinco famílias de modelos documentadas ela não compra economia nenhuma, e em uma dessas duas custa mais.

Tudo até aqui foi um modelo lendo uma imagem. Fazer uma imagem roda em um mecanismo sem tokens, e é por isso que ele é vendido por imagem, não por palavra.

Fornecedores publicam geração de imagem como preço por imagem. Não é. Modelos GPT Image emitem image tokens especializados cuja contagem depende do tamanho e da qualidade solicitados; multiplique as contagens publicadas pela taxa de saída de imagem publicada do GPT Image 1, de $40 por milhão, e compare com os preços por imagem na mesma página:

Nove números derivados contra nove publicados, todos os pares concordando dentro de $0.002.¹¹ O Google é ainda mais explícito e faz a conversão para você na própria página de preços: saída de imagem a $60 por milhão de tokens, «imagens de saída em 1K (1024x1024px) consomem 1120 tokens e equivalem a $0.067 por imagem».¹²

Então um preço por imagem é um preço por token com a contagem embutida. Tudo bem, mas isso esconde algo. Pegue a tabela da geração atual e divida ao contrário:

quality   1024x1024            1024x1536
low       $0.006 -> 200 tok    $0.005 -> 167 tok
medium    $0.053 -> 1767 tok   $0.041 -> 1367 tok
high      $0.211 -> 7033 tok   $0.165 -> 5500 tok

A imagem maior é a mais barata em todas as qualidades. Um canvas de 1024 × 1536 tem 50 % mais pixels que um de 1024 × 1024 e custa 23 % menos tokens em qualidade média. A OpenAI sinaliza isso em uma frase que você pularia — «uma resolução não quadrada maior às vezes pode produzir menos output tokens do que uma resolução menor ou quadrada na mesma configuração de qualidade» — e, na geração anterior do modelo, era o contrário, com retrato custando 50 % mais que quadrado.¹¹ Todo padrão de 1024x1024 escrito antes dessa mudança agora é a opção cara.

Peça a três produtos para falar os mesmos 519 caracteres — cerca de 38 segundos de áudio — e você obtém três sistemas de unidades de dois fornecedores:

O mesmo fornecedor vende as duas unidades: tts-1 da OpenAI é precificado por milhão de caracteres, enquanto gpt-4o-mini-tts é precificado por milhão de tokens, $0.60 de entrada e $12.00 de saída.¹³ Portanto «text-to-speech mais barato» não é uma pergunta com resposta até você dizer o que será falado.

E as duas unidades são cegas a coisas opostas. Um preço por caractere não vê duração: escolha uma voz lenta e deliberada, ou adicione pausas, e a conta não muda enquanto o áudio fica mais longo. Um preço por segundo não vê conteúdo: trinta segundos custam o mesmo seja um parágrafo técnico denso ou alguém contando até dez. Mude a voz e exatamente um dos seus dois fornecedores muda o preço.

Transcrição vai no sentido oposto e é a linha mais simples de toda a fatura — por minuto de áudio, fixo:

whisper                  $0.005960     ($0.006 / min)
gpt-transcribe           $0.004470     ($0.0045 / min)
gpt-4o-mini-transcribe   $0.002980     ($0.003 / min)
gpt-live-transcribe      $0.016887     ($0.017 / min)

Observe a última linha em relação à terceira: fazer isso ao vivo, conforme as palavras chegam, custa 5,7 vezes mais do que fazer em um arquivo finalizado. Essa diferença é o preço de não poder fazer batch, e é o que torna a próxima seção cara.

Agora o número que decide se voz é uma funcionalidade ou um produto.

A ligação: uma conversa de suporte de dez turnos, 149 palavras, que a uma taxa declarada de 150 palavras por minuto dá 59,6 segundos de fala — 21,2 falados pelo cliente, 38,4 falados de volta. As conversões de token são dos próprios fornecedores. OpenAI: «audio tokens em mensagens do usuário são 1 token por 100 ms de áudio, enquanto audio tokens em mensagens do assistant são 1 token por 50 ms».¹⁴ Google: 25 tokens por segundo, nas duas direções, o que sua página de preços confirma ao publicar $12.00 por milhão e $0.018 por minuto na mesma linha.¹²

A conversa se acumula exatamente como o Capítulo 16 disse que aconteceria, porque é o mesmo mecanismo: «a conversa inteira é enviada ao modelo para cada Response... portanto turnos posteriores na sessão serão mais caros».¹⁴ Só que agora o histórico é medido em audio tokens.

Agora a comparação que decide o produto, todos os quatro normalizados para um minuto:

Trinta e oito vezes. Não trinta e oito por cento. A troca idêntica, conduzida em som em vez de texto, é quase duas ordens de grandeza mais cara, e nada dessa diferença é uma margem que alguém escolheu cobrar — é a taxa de conversão. Um segundo de áudio do assistant são vinte tokens. Esse mesmo segundo carrega 2,5 palavras na taxa declarada, e a transcrição medida roda a 1,26 tokens por palavra, então como texto ele tem 3,15 tokens. Som é um pacote 6,3 vezes mais volumoso para o mesmo significado, e cada um de seus tokens é cobrado a 5,3 vezes a taxa de saída de texto e 16 vezes a taxa de entrada de texto. Multiplique uma razão de volume por uma razão de preço e a ordem de grandeza já está lá antes de qualquer contabilidade começar.

Duas consequências operacionais saem direto da tabela.

Audio caching não é uma otimização, é o modelo de negócio. Entrada de áudio em cache custa $0.40 por milhão contra $32.00 nova — um desconto de 98,75 % que reduz a ligação pela metade. A regra é a do Capítulo 16, sem mudanças: o cache corresponde a um prefixo, então qualquer coisa inserida no início da conversa no meio da ligação o destrói, e o lugar natural para colocar «o cliente agora está verificado» é exatamente ali.

E nada que você faça no cliente desfatura um som. O usuário fala por cima do assistant, seu código interrompe a reprodução, o alto-falante fica em silêncio. O que já tinha sido gerado já foi cobrado, porque o faturamento acumula quando a resposta é criada; e, pela regra do Capítulo 16, o que permanece na conversa é reenviado, como áudio de entrada, em todos os turnos seguintes. O Capítulo 14 fez esse ponto sobre abortar um stream de texto. Em voz, custa trinta vezes mais.

Vídeo é vendido por segundo por alguns fornecedores e por clipe por outros, com faixas para resolução e às vezes para duração. Esses dois formatos não diferem apenas em conveniência; eles se cruzam.

O fornecedor por clipe é mais caro que o por segundo abaixo de 1,2 segundo e 16,7 vezes mais barato aos vinte. Nenhuma ordenação desses dois modelos sobrevive a uma mudança no comprimento do clipe, então «qual modelo de vídeo é mais barato» não é uma pergunta sobre modelos.

A última linha é pior, e é o coração honesto do capítulo. mochi é cobrado contra segundos reais de GPU — o tempo de predição medido do job — a $0.001400 por segundo em uma A100 e $0.001525 em uma H100, que são as taxas da máquina alugada e nada mais.¹⁵ Essa é uma tarifa perfeitamente precisa e não é um preço, porque a quantidade que ela multiplica é desconhecida até depois de você ter se comprometido a pagá-la. A linha acima assume doze GPU-segundos por segundo de saída; quadruplique essa suposição e ela sai da faixa mais barata, e só em seis vezes cai no meio da tabela. É a única tarifa nesta página que você não consegue colocar em uma cotação.

Então: tokens, image tokens, caracteres, minutos, segundos de vídeo, clipes inteiros, GPU-segundos, unidades fixas. Oito quantidades, e a única forma de colocá-las em um eixo é declarar uma carga de trabalho e precificá-la.

Essa é a extensão do computeCost do Capítulo 16 — a mesma maquinaria de faixas, agora com critérios que não são o comprimento do prompt:

export interface MediaCriteria {
  resolution?: string[]; quality?: string[];
  hasAudio?: boolean; maxDurationSeconds?: number;
}
export interface MediaTier { when?: MediaCriteria; price: number }
export type MediaRate = number | MediaTier[];

const matches = (when: MediaCriteria, u: Usage) => {
  const inList = (l?: string[], v?: string) => !l || (v !== undefined && l.includes(v));
  if (!inList(when.resolution, u.resolution)) return false;
  if (!inList(when.quality, u.quality)) return false;
  if (when.hasAudio !== undefined && when.hasAudio !== (u.hasAudio ?? false)) return false;
  if (when.maxDurationSeconds !== undefined
      && (u.videoSeconds ?? 0) > when.maxDurationSeconds) return false;   
  return true;
};

const mediaPrice = (rate: MediaRate | undefined, u: Usage): number => {
  if (rate === undefined) return 0;
  if (typeof rate === "number") return rate;
  for (const t of rate.filter((t) => t.when)) if (matches(t.when!, u)) return t.price;
  return rate.find((t) => !t.when)?.price ?? 0;      // the tier with no criteria is the default
};

export function computeCost(p: Pricing, u: Usage): number {
  let c = textCost(p, u);                             // Chapter 16, unchanged
  if (p.imageInputToken || p.imageOutputToken) {
    c += (u.imageInputTokens ?? 0) * (p.imageInputToken ?? 0)
       + (u.imageOutputTokens ?? 0) * (p.imageOutputToken ?? 0);
  } else if (p.imageUnit !== undefined) c += (u.images ?? 1) * mediaPrice(p.imageUnit, u);  
  if (p.videoSecond !== undefined) c += (u.videoSeconds ?? 0) * mediaPrice(p.videoSecond, u);
  if (p.videoUnit   !== undefined) c += (u.videoCount ?? 1)   * mediaPrice(p.videoUnit, u);
  c += (u.audioInputTokens ?? 0)       * (p.audioInputToken ?? 0)
     + (u.cachedAudioInputTokens ?? 0) * (p.cachedAudioInputToken ?? p.audioInputToken ?? 0)
     + (u.audioOutputTokens ?? 0)      * (p.audioOutputToken ?? 0)
     + (u.computeSeconds ?? 0)         * (p.computeSecond ?? 0)
     + (u.chars ?? 0)                  * (p.perChar ?? 0)
     + (u.minutes ?? 0)                * (p.perMinute ?? 0);
  return c;
}

As duas linhas marcadas são onde ele quebra. Uma tarifa cotada por unidade multiplica u.images ?? 1; uma tarifa cotada por token multiplica algo cujo padrão é zero. Alimente ambas com uso vazio — o formato que você obtém quando uma medição falhou — e veja:

per image (nano-banana-pro)     empty usage => $0.1500
per clip  (hailuo-02)           empty usage => $0.1500
per unit  (a cloned voice)      empty usage => $3.0000
per token (gpt-image-2)         empty usage => $0.0000
per second (veo-3.1)            empty usage => $0.0000
per GPU-second (mochi)          empty usage => $0.0000

Nada aconteceu, seis vezes, e custou três dólares uma vez e nada cinco vezes. Isso não é diferença de arredondamento; é uma decisão sobre o que um número ausente significa, tomada separadamente para cada unidade e nunca escrita. A regra sensata é que um campo que ninguém mediu permanece ausente, porque «não medido» e «medido e deu zero» são coisas diferentes. Esta função discorda em silêncio.

A segunda falha é duração. A tarifa por clipe seleciona sua faixa com maxDurationSeconds contra u.videoSeconds ?? 0, então um uso que nunca registrou duração corresponde à faixa mais curta:

duration recorded    ->  $0.45
duration missing     ->  $0.27

Quarenta por cento de desconto por não saber quanto durou o vídeo. Ambos os bugs têm a mesma raiz: um padrão escolhido por conveniência dentro de uma função cujo trabalho inteiro é ser exata.

Com custos computáveis, a comparação precisa da outra metade — uma carga de trabalho representativa declarada, uma por engine, exposta publicamente para que um leitor possa discordar dela:

export const representative = {
  text:   { blend: [[{ promptTokens: 1e6 }, 0.25], [{ completionTokens: 1e6 }, 0.75]] },
  image:  { images: 1, imageInputTokens: 50, imageOutputTokens: 1500 },
  video:  { videoSeconds: 5, videoCount: 1, resolution: "1080p", hasAudio: true, computeSeconds: 60 },
  voice:  { chars: 1000, computeSeconds: 10 },
  stt:    { minutes: 1 },
};

Cada uma dessas linhas é um argumento. Texto mistura um quarto de entrada e três quartos de saída porque o uso real pende para a saída; uma mistura meio a meio classifica os modelos de outro jeito. A carga de imagem assume 1.500 output tokens, entre os 1.056 da OpenAI para um quadrado médio e os 1.584 para um retrato médio. Vídeo assume cinco segundos em 1080p, e acabamos de ver dois fornecedores trocarem de lugar em 1,2 segundo. A entrada de computação assume sessenta GPU-segundos porque não há mais nada a assumir.

Esse é o método, e é o único honesto disponível: você não pode comparar preços em unidades diferentes; só pode comparar o custo de uma carga de trabalho que você escreveu. Qualquer tabela que classifique modelos multimodais sem imprimir sua carga de trabalho está classificando as próprias suposições.

Agora você consegue precificar qualquer coisa que um modelo possa produzir, em qualquer unidade em que ela seja vendida, e dizer em voz alta qual carga de trabalho sua comparação assumiu. Isso fecha a fatura que o Capítulo 16 abriu, e fecha a Parte III: tudo do Capítulo 14 até aqui tratou de uma chamada — como fazê-la, o que colocar nela, como amostrá-la, o que ela retorna, quanto custa.

O Capítulo 22 muda a unidade de análise, e a mudança é cara. Um agent não é uma chamada; é um loop que decide por si mesmo quantas chamadas fazer, e a aritmética dos dois últimos capítulos é o que transforma isso de um diagrama de arquitetura em um orçamento. Ele começa fazendo a mesma pergunta ao mesmo modelo duas vezes, com uma ferramenta adicionada ao catálogo na segunda vez, e medindo o que essa única ferramenta fez: uma chamada virou duas, trinta e nove input tokens viraram 420.

Se isso faz dele um agent depende de qual das duas definições publicadas você abre, e elas não concordam. Uma delas não concorda consigo mesma.

Cada preço, fórmula e taxa de conversão neste capítulo foi lido da própria página do fornecedor em 7 de setembro de 2026 e é citado com essa data, porque todos eles vão mudar. As contagens de token, custos e comparações foram calculados sobre esses dados pelo código impresso acima, em uma máquina, sem nenhuma chamada de API paga — o que também é o motivo honesto para não haver uma única afirmação de latência neste capítulo.

As funções de image-token, as tabelas de custo, o detalhamento da chamada de voz e os resultados de uso vazio foram produzidos pelo TypeScript impresso neste capítulo, executado no Node 22. O diálogo usado para a comparação de voz tem 149 palavras e foi tokenizado com tiktoken sob a codificação o200k_base em 188 tokens; sua duração vem de uma taxa declarada de 150 palavras por minuto, que é um parâmetro da comparação e não uma medição. Cada número de fornecedor carrega a nota de rodapé que nomeia a página de onde veio.