Prezos multimodais: o que realmente facturan as imaxes, o audio e o vídeo

Un transformer toma unha secuencia de vectores. Non ten opinión sobre de onde viñeron. O capítulo 8 alimentouno con embeddings buscados a partir dun id de token; nada na arquitectura esixe esa busca.

Así que: corta a imaxe en cadrados fixos, aplana cada cadrado nunha lista de números e pasa cada lista por unha capa lineal aprendida para obter un vector da largura do modelo. Un parche de 32 × 32 píxeles de cor son $32 \times 32 \times 3 = 3072$ números; a proxección $E \in \mathbb{R}^{d \times 3072}$ convérteo nun vector $d$-dimensional, exactamente coa forma coa que chega un token de texto. Iso é todo, e é o artigo cuxo título o di: unha imaxe vale 16 × 16 palabras.¹ Engade unha codificación posicional para que o modelo saiba que cadrado estaba onde, intercala os resultados cos embeddings do texto, e a secuencia que le o modelo é parte imaxe e parte frase.

Tres artigos fixérono produto. CLIP adestrou un codificador de imaxe e un codificador de texto para poñerse de acordo, sobre catrocentos millóns de pares raspados, e aí foi onde a idea de que píxeles e palabras poden compartir un espazo deixou de ser unha hipótese.² Flamingo atornillou un codificador de visión conxelado a un modelo de linguaxe conxelado con algunhas capas ponte adestradas.³ LLaVA mostrou que a ponte podía ser unha soa proxección lineal e que o seguimento de instrucións podía ensinarse con datos xerados, e por iso todos os modelos abertos de visión-linguaxe desde entón teñen máis ou menos a mesma forma.⁴

A consecuencia para a túa factura é inmediata e pouco glamurosa: os parches son posicións na secuencia, así que son input tokens, así que pagas por eles á tarifa de entrada. Cantos son é aritmética, e cada provedor faina doutro xeito.

Cada regra de abaixo está implementada a partir da documentación do propio provedor e comprobada contra os exemplos resoltos desa mesma documentación.

OpenAI cobre a imaxe con parches de 32 × 32 e multiplica o reconto por un factor por modelo. Se o reconto de parches supera o orzamento dese modelo e nivel de detalle, a imaxe redúcese ata encaixar:

Anthropic cóbrea con parches de 28 × 28, un visual token cada un, e pon tope tanto ao lado longo como ao reconto de tokens: 1,568 píxeles e 1,568 tokens nos modelos de nivel estándar, 2,576 e 4,784 no nivel de alta resolución. As imaxes demasiado grandes escálanse ao maior tamaño que encaixe nos dous.⁵

Google non conta píxeles en absoluto. Unha imaxe cos dous lados en 384 píxeles ou menos custa unha tarifa plana de 258 tokens. Calquera cousa maior córtase en tiles de 258 tokens cada un, e a grella de tiles sae dunha unidade de recorte 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;      
}

Executa cada unha contra os números que imprime o seu propio provedor:

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

Imprímense nove coincidencias; a execución completa comproba quince, xa que a táboa de Anthropic dá os dous niveis para os seis tamaños. Agora as regras son túas para executalas sobre calquera fotografía que teñas, que é a cuestión: estas son as únicas tres funcións deste capítulo que non podes obter dunha páxina de prezos.

Pasa a mesma fotografía 4:3 polas tres regras en seis tamaños:

Le a última columna cara abaixo. En canto a imaxe supera os 384 píxeles, o número xa non cambia nunca, e iso non é unha coincidencia nin un tope. Substitúe a unidade de recorte de volta na fórmula de tiles, para unha imaxe polo menos tan ancha como alta:

O tamaño cancélase. Os image tokens de Google dependen da relación de aspecto e de nada máis. Unha fotografía 4:3 son catro tiles tanto se é unha miniatura como se é un póster. Ese único feito alxébrico é toda a explicación do cero na táboa de aforro de arriba, e ningunha páxina de prezos en ningures o di.

As outras dúas columnas, en cambio, chegan a un tope, a alturas diferentes e por razóns diferentes —Anthropic nun teito declarado de tokens, OpenAI nun orzamento de parches despois dun límite de píxeles—, e por iso as tres curvas crúzanse en tamaños distintos.

Agora rómpao. A maneira obvia de gastar menos nun modelo de visión é pedir menos detalle, así que envía detail: "low":

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

Pedir menos detalle custou 25 % máis. Non é un bug, e OpenAI dio nunha liña da táboa de tamaños: nesa familia de modelos, low usa un límite de 2048 píxeles cun orzamento de 6,144 parches mentres high usa o mesmo límite de píxeles cun orzamento de 2,500 parches, "so it can use more tokens than high".⁷ A palabra low nomea un axuste de fidelidade, non un prezo: en dúas das cinco familias de modelos documentadas non compra ningún aforro, e nunha desas dúas custa máis.

Todo ata agora foi un modelo lendo unha imaxe. Facela executa un mecanismo sen tokens, e esa é a razón pola que se vende pola imaxe e non pola palabra.

Os provedores publican a xeración de imaxes como prezo por imaxe. Non o é. Os modelos GPT Image emiten image tokens especializados cuxo reconto depende do tamaño e da calidade solicitados; multiplica os recontos publicados pola tarifa publicada de saída de imaxe de GPT Image 1, $40 por millón, e compara cos prezos por imaxe da mesma páxina:

Nove cifras derivadas contra nove publicadas, todos os pares coincidindo dentro de $0.002.¹¹ Google é aínda máis explícito e fai a conversión por ti na propia páxina de prezos: saída de imaxe a $60 por millón de tokens, "output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image".¹²

Así que un prezo por imaxe é un prezo por token co reconto dobrado dentro. Está ben, e agocha algo. Colle a táboa da xeración actual e divide cara atrás:

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 imaxe maior é a máis barata en todas as calidades. Un canvas de 1024 × 1536 ten 50 % máis píxeles ca un de 1024 × 1024 e custa 23 % menos tokens en medium. OpenAI advírteo nunha frase que saltarías —"a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting"— e na xeración anterior de modelos ía ao revés, co retrato custando 50 % máis ca o cadrado.¹¹ Todo valor por defecto de 1024x1024 escrito antes dese cambio é agora a opción cara.

Pídelles a tres produtos que falen os mesmos 519 caracteres —uns 38 segundos de audio— e obtés tres sistemas de unidades de dous provedores:

O mesmo provedor vende as dúas unidades: tts-1 de OpenAI ten prezo por millón de caracteres mentres gpt-4o-mini-tts ten prezo por millón de tokens, $0.60 de entrada e $12.00 de saída.¹³ Así que "o text-to-speech máis barato" non é unha pregunta con resposta ata que digas que vas falar.

E as dúas unidades son cegas a cousas opostas. Un prezo por carácter non ve a duración: escolle unha voz lenta e deliberada, ou engade pausas, e a factura non se move mentres o audio se fai máis longo. Un prezo por segundo non ve o contido: trinta segundos custan o mesmo tanto se son un parágrafo técnico denso como se alguén conta ata dez. Cambia a voz e exactamente un dos teus dous provedores recalcula o prezo.

A transcrición vai ao revés e é a liña máis simple de toda a factura: por minuto de audio, plana:

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)

Fíxate na última fila fronte á terceira: facelo en directo, mentres chegan as palabras, custa 5,7 veces facelo sobre un ficheiro rematado. Esa diferenza é o prezo de non poder facer batch, e é o que encarece a sección seguinte.

Agora o número que decide se a voz é unha funcionalidade ou un produto.

A chamada: unha conversa de soporte de dez quendas, 149 palabras, que a unha taxa declarada de 150 palabras por minuto son 59,6 segundos de fala: 21,2 falados pola persoa que chama, 38,4 devoltos. As conversións de token son as dos propios provedores. OpenAI: "audio tokens in user messages are 1 token per 100 ms of audio, while audio tokens in assistant messages are 1 token per 50 ms".¹⁴ Google: 25 tokens por segundo, nas dúas direccións, que a súa páxina de prezos confirma ao publicar $12.00 por millón e $0.018 por minuto na mesma liña.¹²

A conversa acumúlase exactamente como dixo o capítulo 16, porque é o mesmo mecanismo: "the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive".¹⁴ Só que agora o historial mídese en audio tokens.

Agora a comparación que decide o produto, as catro normalizadas a un minuto:

Trinta e oito veces. Non trinta e oito por cento. O intercambio idéntico, realizado en son en vez de texto, é case dúas ordes de magnitude máis caro, e nada desa diferenza é unha marxe que alguén decidiu cobrar: é a taxa de conversión. Un segundo de audio de assistant son vinte tokens. Ese mesmo segundo leva 2,5 palabras á taxa declarada, e a transcrición medida vai a 1,26 tokens por palabra, así que como texto son 3,15 tokens. O son é un paquete 6,3 veces máis voluminoso para o mesmo significado, e cada un dos seus tokens factúrase a 5,3 veces a tarifa de saída de texto e a 16 veces a tarifa de entrada de texto. Multiplica unha relación de volume por unha relación de prezo e a orde de magnitude xa está aí antes de que empece a contabilidade.

Dúas consecuencias operativas saen directamente da táboa.

Audio caching non é unha optimización, é o modelo de negocio. A entrada de audio cached custa $0.40 por millón fronte a $32.00 nova: un desconto do 98,75 % que reduce á metade a chamada. A regra é a do capítulo 16, sen cambios: a cache coincide cun prefixo, así que calquera cousa inserida ao comezo da conversa a media chamada destrúea, e o lugar natural para poñer "a persoa que chama xa está verificada" é exactamente aí.

E nada do que fagas no cliente desf factura un son. O usuario fala por enriba do assistant, o teu código detén a reprodución, o altofalante cala. O que xa fora xerado xa foi cobrado, porque a facturación acumúlase cando se crea a resposta; e pola regra do capítulo 16, todo o que queda na conversa reenvíase como audio de entrada en cada quenda posterior. O capítulo 14 fixo este punto sobre abortar un stream de texto. En voz custa trinta veces máis.

O vídeo véndese por segundo nalgúns provedores e por clip noutros, con niveis por resolución e ás veces por duración. Esas dúas formas non difiren só en comodidade; crúzanse.

O provedor por clip é máis caro ca o de por segundo por baixo de 1,2 segundos e 16,7 veces máis barato aos vinte. Ningunha orde entre eses dous modelos sobrevive a un cambio de lonxitude do clip, así que "que modelo de vídeo é máis barato" non é unha pregunta sobre modelos.

A última fila é peor, e é o corazón honesto do capítulo. mochi factúrase contra segundos reais de GPU —o tempo de predición medido do traballo— a $0.001400 por segundo nun A100 e $0.001525 nun H100, que son as tarifas da máquina alugada e nada máis.¹⁵ Iso é unha tarifa perfectamente precisa e non é un prezo, porque a cantidade pola que multiplica é descoñecida ata despois de te comprometeres a pagala. A fila anterior asume doce GPU-segundos por segundo de saída; cuadruplica esa suposición e sae da franxa máis barata, e só a seis veces aterra a media táboa. É a única tarifa desta páxina que non podes meter nun orzamento.

Así que: tokens, image tokens, caracteres, minutos, segundos de vídeo, clips enteiros, GPU-segundos, unidades planas. Oito cantidades, e a única maneira de poñelas nun só eixe é declarar unha carga de traballo e poñerlle prezo.

Esa é a extensión de computeCost do capítulo 16: a mesma maquinaria de niveis, agora con criterios que non son a lonxitude 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 dúas liñas marcadas son onde rompe. Unha tarifa cotizada por unidade multiplica u.images ?? 1; unha tarifa cotizada por token multiplica algo que por defecto é cero. Dálle ás dúas un uso baleiro —a forma que obtés cando unha medición fallou— e observa:

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

Non pasou nada, seis veces, e custou tres dólares unha vez e nada cinco veces. Iso non é unha diferenza de redondeo; é unha decisión sobre que significa un número ausente, tomada por separado para cada unidade e nunca escrita. A regra sensata é que un campo que ninguén mediu segue ausente, porque "non medido" e "medido e saíu cero" son cousas distintas. Esta función discrepa en silencio.

O segundo fallo é a duración. A tarifa por clip escolle o seu nivel con maxDurationSeconds contra u.videoSeconds ?? 0, así que un uso que nunca rexistrou unha duración coincide co nivel máis curto:

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

Corenta por cento de desconto por non saber canto duraba o vídeo. Os dous bugs teñen a mesma raíz: un valor por defecto escollido por comodidade dentro dunha función cuxo traballo enteiro é ser exacta.

Cos custos calculables, a comparación necesita a outra metade: unha carga de traballo representativa declarada, unha por motor, explicada en público para que un lector poida discrepar:

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 unha desas liñas é un argumento. O texto mestura un cuarto de entrada e tres cuartos de saída porque o uso real se inclina á saída; unha mestura cincuenta-cincuenta ordena os modelos doutro xeito. A carga de traballo de imaxe asume 1,500 tokens de saída, entre os 1,056 de OpenAI para un cadrado medium e os 1,584 para un retrato medium. Vídeo asume cinco segundos a 1080p, e acabamos de ver dous provedores intercambiar posicións en 1,2 segundos. A entrada de compute asume sesenta GPU-segundos porque non hai outra cousa que asumir.

Ese é o método, e é o único honesto dispoñible: non podes comparar prezos en unidades distintas; só podes comparar o custo dunha carga de traballo que deixaches por escrito. Calquera táboa que clasifique modelos multimodais sen imprimir a súa carga de traballo está clasificando as súas propias suposicións.

Agora podes poñer prezo a calquera cousa que poida producir un modelo, na unidade na que se venda, e dicir en voz alta que carga de traballo asumiu a túa comparación. Iso pecha a factura que abriu o capítulo 16, e pecha a Parte III: todo desde o capítulo 14 ata aquí tratou de unha chamada: como facela, que poñer nela, como facer sampling, que devolve, que custa.

O capítulo 22 cambia a unidade de análise, e o cambio é caro. Un agent non é unha chamada; é un bucle que decide por si mesmo cantas chamadas facer, e a aritmética dos dous últimos capítulos é o que converte iso dun diagrama de arquitectura nun orzamento. Comeza facendo a mesma pregunta ao mesmo modelo dúas veces, cunha ferramenta engadida ao catálogo a segunda vez, e medindo o que fixo esa única ferramenta: unha chamada converteuse en dúas, trinta e nove input tokens convertéronse en 420.

Que iso o converta nun agent depende de cal das dúas definicións publicadas abras, e non coinciden. Unha delas nin sequera coincide consigo mesma.

Cada prezo, fórmula e taxa de conversión deste capítulo leuse na páxina do propio provedor o 7 de setembro de 2026 e cítase con esa data, porque todos van moverse. Os recontos de token, custos e comparacións calculáronse sobre eses datos co código impreso arriba, nunha máquina, sen facer ningunha chamada de API de pago; esa é tamén a razón honesta pola que non hai nin unha soa afirmación de latencia neste capítulo.

As funcións de image-token, as táboas de custo, o desagregado da chamada de voz e os resultados de uso baleiro producíronse co TypeScript impreso neste capítulo, executado en Node 22. O diálogo usado para a comparación de voz ten 149 palabras e foi tokenized con tiktoken baixo a codificación o200k_base en 188 tokens; a súa duración deriva dunha taxa declarada de 150 palabras por minuto, que é un parámetro da comparación e non unha medición. Cada cifra de provedor leva a nota que nomea a páxina da que saíu.