Prețuri multimodale: ce facturează de fapt imaginile, audio și video

Un transformer primește o secvență de vectori. Nu are nicio opinie despre locul de unde au venit. Capitolul 8 i-a dat embeddings căutate după un id de token; nimic din arhitectură nu cere neapărat lookupul.

Așadar: tai imaginea în pătrate fixe, aplatizezi fiecare pătrat într-o listă de numere și treci fiecare listă printr-un strat liniar învățat ca să obții un vector cu lățimea modelului. Un patch de pixeli colorați de 32 × 32 este $32 \times 32 \times 3 = 3072$ numere; proiecția $E \in \mathbb{R}^{d \times 3072}$ îl transformă într-un vector $d$-dimensional, exact forma în care sosește un text token. Asta e tot, iar lucrarea o spune chiar în titlu: o imagine valorează 16 × 16 cuvinte.¹ Adaugi o codare pozițională ca modelul să știe ce pătrat era unde, intercalezi rezultatele cu text embeddings, iar secvența citită de model este parțial imagine și parțial propoziție.

Trei lucrări au transformat ideea în produs. CLIP a antrenat un encoder de imagine și un encoder de text să se pună de acord, pe patru sute de milioane de perechi colectate de pe web, iar acolo ideea că pixelii și cuvintele pot împărți același spațiu a încetat să mai fie o ipoteză.² Flamingo a prins un encoder vizual înghețat de un language model înghețat cu câteva straturi-punte antrenate.³ LLaVA a arătat că puntea poate fi o singură proiecție liniară și că urmarea instrucțiunilor poate fi predată cu date generate, motiv pentru care aproape fiecare model vision-language deschis de atunci arată cam la fel.⁴

Consecința pentru factura ta este imediată și deloc spectaculoasă: patchurile sunt poziții în secvență, deci sunt input tokens, deci plătești pentru ele la tariful de input. Câte sunt ține de aritmetică, iar fiecare furnizor o face altfel.

Fiecare regulă de mai jos este implementată din documentația proprie a furnizorului și verificată cu exemplele lucrate din aceeași documentație.

OpenAI acoperă imaginea cu patchuri de 32 × 32 și înmulțește numărul cu un factor pe model. Dacă numărul de patchuri depășește bugetul pentru acel model și acel nivel de detaliu, imaginea este scalată în jos până încape:

Anthropic o acoperă cu patchuri de 28 × 28, câte un visual token fiecare, și plafonează atât latura lungă, cât și numărul de tokens — 1.568 pixeli și 1.568 tokens pe modelele standard-tier, 2.576 și 4.784 pe tierul high-resolution. Imaginile supradimensionate sunt scalate la cea mai mare dimensiune care încape în ambele limite.⁵

Google nu numără pixelii deloc. O imagine cu ambele laturi de cel mult 384 de pixeli costă fix 258 tokens. Orice este mai mare se taie în tile-uri de 258 tokens fiecare, iar grila de tile-uri vine dintr-o unitate de crop 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;      
}

Rulează fiecare pe numerele tipărite de propriul furnizor:

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

Sunt afișate nouă concordanțe; rularea completă verifică cincisprezece, fiindcă tabelul Anthropic dă ambele tieruri pentru toate cele șase dimensiuni. Regulile sunt acum ale tale și le poți rula pe orice fotografie ai, acesta fiind scopul: acestea sunt singurele trei funcții din capitol pe care nu le poți obține dintr-o pagină de prețuri.

Trece aceeași fotografie 4:3 prin toate trei, la șase dimensiuni:

Citește ultima coloană în jos. Odată ce fotografia trece de 384 de pixeli, numărul nu se mai schimbă niciodată, iar asta nu este o coincidență sau un plafon. Pune unitatea de crop înapoi în formula de tile-uri, pentru o imagine cel puțin la fel de lată pe cât este de înaltă:

Dimensiunea se anulează. Google's image tokens depind de raportul de aspect și de nimic altceva. O fotografie 4:3 are patru tile-uri indiferent dacă este o miniatură sau un poster. Acest singur fapt algebric este întreaga explicație a zeroului din tabelul de economii de mai sus, și nicio pagină de prețuri nu îl afirmă.

Celelalte două coloane se plafonează în schimb, la înălțimi diferite și din motive diferite — Anthropic la un plafon declarat de tokens, OpenAI la un buget de patchuri după o limită de pixeli — motiv pentru care cele trei curbe se intersectează la dimensiuni diferite.

Acum strică-l. Modul evident de a cheltui mai puțin pe un vision model este să ceri mai puțin detaliu, deci trimite detail: "low":

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

A cere mai puțin detaliu a costat cu 25 % mai mult. Nu este un bug, iar OpenAI o spune într-un singur rând din tabelul de dimensionare: pe acea familie de modele, low folosește o limită de 2048 de pixeli cu un buget de 6.144 patchuri, în timp ce high folosește aceeași limită de pixeli cu un buget de 2.500 de patchuri, „so it can use more tokens than high”.⁷ Cuvântul low numește o setare de fidelitate, nu un preț: pe două dintre cele cinci familii de modele documentate nu cumpără nicio economie, iar pe una dintre acestea două costă mai mult.

Tot ce a fost până acum era un model care citește o imagine. A face una rulează pe un mecanism fără tokens deloc, iar acesta este motivul pentru care se vinde la imagine, nu la cuvânt.

Furnizorii publică generarea de imagini ca preț per imagine. Nu este. Modelele GPT Image emit image tokens specializați, al căror număr depinde de dimensiunea și calitatea cerute; înmulțește numerele publicate cu tariful publicat de output imagine al GPT Image 1, $40 per milion, și compară cu prețurile per imagine de pe aceeași pagină:

Nouă cifre derivate față de nouă publicate, fiecare pereche concordând în limita a $0.002.¹¹ Google este și mai explicit și face conversia pentru tine chiar pe pagina de prețuri: output imagine la $60 per milion tokens, „output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image”.¹²

Deci un preț per imagine este un preț per token cu numărul inclus. Ceea ce este în regulă, dar ascunde ceva. Ia tabelul generației curente și împarte invers:

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

Imaginea mai mare este cea mai ieftină la fiecare calitate. Un canvas de 1024 × 1536 are cu 50 % mai mulți pixeli decât unul de 1024 × 1024 și costă cu 23 % mai puțini tokens la medium. OpenAI semnalează asta într-o propoziție peste care ai trece — „a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting” — iar pe generația anterioară de model mergea invers, portretul costând cu 50 % mai mult decât pătratul.¹¹ Orice default de 1024x1024 scris înainte de acea schimbare este acum opțiunea scumpă.

Cere trei produse să rostească aceleași 519 caractere — aproximativ 38 de secunde de audio — și primești trei sisteme de unități de la doi furnizori:

Același furnizor vinde ambele unități: tts-1 de la OpenAI este tarifat per milion de caractere, în timp ce gpt-4o-mini-tts este tarifat per milion de tokens, $0.60 in și $12.00 out.¹³ Deci „cel mai ieftin text-to-speech” nu este o întrebare cu răspuns până nu spui ce rostești.

Iar cele două unități sunt oarbe la lucruri opuse. Un preț per caracter nu vede durata: alege o voce lentă, deliberată, sau adaugă pauze, iar factura nu se mișcă, deși audio-ul devine mai lung. Un preț per secundă nu vede conținutul: treizeci de secunde costă la fel fie că sunt un paragraf tehnic dens, fie că cineva numără până la zece. Schimbă vocea și exact unul dintre cei doi furnizori îți recalculează prețul.

Transcrierea merge în sens invers și este cea mai simplă linie din toată factura — per minut de audio, fix:

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)

Observă ultimul rând față de al treilea: să o faci live, pe măsură ce sosesc cuvintele, costă de 5,7 ori cât să o faci pe un fișier terminat. Diferența este prețul faptului că nu poți face batch, și asta face următoarea secțiune scumpă.

Acum numărul care decide dacă vocea este o funcționalitate sau un produs.

Apelul: o conversație de suport în zece ture, 149 de cuvinte, care la un ritm declarat de 150 de cuvinte pe minut înseamnă 59,6 secunde de vorbire — 21,2 rostite de apelant, 38,4 rostite înapoi. Conversiile în token sunt ale furnizorilor. 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 pe secundă, în ambele direcții, lucru confirmat de pagina sa de prețuri prin publicarea a $12.00 per milion și $0.018 pe minut pe același rând.¹²

Conversația se acumulează exact cum a spus Capitolul 16, fiindcă este același mecanism: „the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive”.¹⁴ Doar că acum istoricul este măsurat în audio tokens.

Acum comparația care decide produsul, toate patru normalizate la un minut:

De treizeci și opt de ori. Nu treizeci și opt la sută. Schimbul identic, purtat în sunet în loc de text, este aproape cu două ordine de mărime mai scump, iar nimic din această diferență nu este o marjă pe care cineva a ales să o perceapă — este rata de conversie. O secundă de audio de assistant înseamnă douăzeci de tokens. Aceeași secundă poartă 2,5 cuvinte la ritmul declarat, iar transcrierea măsurată rulează la 1,26 tokens pe cuvânt, deci ca text înseamnă 3,15 tokens. Sunetul este un pachet de 6,3 ori mai voluminos pentru același sens, iar fiecare dintre tokens lui este facturat la 5,3 ori tariful de text output și de 16 ori tariful de text input. Înmulțește un raport de volum cu un raport de preț și ordinul de mărime este deja acolo înainte să înceapă contabilitatea.

Două consecințe operaționale ies direct din tabel.

Audio caching nu este o optimizare, este modelul de business. Cached audio input costă $0.40 per milion față de $32.00 fresh — o reducere de 98,75 % care înjumătățește apelul. Regula este cea din Capitolul 16, neschimbată: cache-ul potrivește un prefix, deci orice inserat în fața conversației în mijlocul apelului îl distruge, iar locul natural în care să pui „apelantul este acum verificat” este exact acolo.

Și nimic din ce faci în client nu dez-facturează un sunet. Userul vorbește peste assistant, codul tău oprește redarea, difuzorul tace. Orice fusese deja generat fusese deja taxat, fiindcă facturarea se acumulează când răspunsul este creat; iar după regula din Capitolul 16, orice rămâne în conversație este retrimis, ca input audio, la fiecare tură de după. Capitolul 14 a făcut observația aceasta despre oprirea unui text stream. În voce costă de treizeci de ori mai mult.

Video-ul este vândut per secundă de unii furnizori și per clip de alții, cu tieruri pentru rezoluție și uneori pentru durată. Cele două forme nu diferă doar ca conveniență; se intersectează.

Furnizorul per clip este mai scump decât cel per secundă sub 1,2 secunde și de 16,7 ori mai ieftin la douăzeci. Nicio ordonare a acestor două modele nu supraviețuiește unei schimbări de lungime a clipului, deci „care video model este cel mai ieftin” nu este o întrebare despre modele.

Ultimul rând este mai rău, și este inima onestă a capitolului. mochi este facturat după secunde GPU reale — timpul de predicție măsurat al jobului — la $0.001400 pe secundă pe un A100 și $0.001525 pe un H100, care sunt tarifele mașinii închiriate și nimic altceva.¹⁵ Este un tarif perfect precis și nu este un preț, fiindcă mărimea pe care o înmulțește este necunoscută până după ce te-ai angajat să plătești. Rândul de mai sus presupune douăsprezece GPU-seconds per secundă de output; cvadruplează presupunerea și iese din banda cea mai ieftină, iar abia la de șase ori ajunge la mijlocul tabelului. Este singurul tarif de pe pagina aceasta pe care nu îl poți pune într-o ofertă.

Deci: tokens, image tokens, caractere, minute, secunde video, clipuri întregi, GPU seconds, unități fixe. Opt mărimi, iar singura cale de a le pune pe o singură axă este să declari un workload și să îi pui preț.

Aceasta este extensia lui computeCost din Capitolul 16 — aceeași mașinărie de tieruri, acum cu criterii care nu sunt lungimea promptului:

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

Cele două linii marcate sunt locul în care se rupe. Un tarif cotat per unitate înmulțește u.images ?? 1; un tarif cotat per token înmulțește ceva care implicit este zero. Dă-le amândurora o utilizare goală — forma pe care o primești când o măsurare a eșuat — și privește:

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

Nu s-a întâmplat nimic, de șase ori, și a costat trei dolari o dată și nimic de cinci ori. Nu este o diferență de rotunjire; este o decizie despre ce înseamnă un număr absent, luată separat pentru fiecare unitate și nescrisă nicăieri. Regula sănătoasă este ca un câmp pe care nu l-a măsurat nimeni să rămână absent, fiindcă „nemăsurat” și „măsurat și ieșit zero” sunt lucruri diferite. Această funcție nu este de acord, în tăcere.

Al doilea eșec este durata. Tariful pe clip își alege tierul cu maxDurationSeconds față de u.videoSeconds ?? 0, așa că o utilizare care nu a înregistrat niciodată o durată se potrivește cu cel mai scurt tier:

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

Patruzeci la sută reducere pentru că nu știi cât a durat video-ul. Ambele buguri au aceeași rădăcină: un default ales pentru conveniență într-o funcție a cărei întreagă treabă este să fie exactă.

Cu costurile calculabile, comparația are nevoie de cealaltă jumătate — un workload reprezentativ declarat, câte unul per engine, spus public ca un cititor să poată să nu fie de acord cu el:

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 },
};

Fiecare dintre acele linii este un argument. Textul amestecă un sfert input și trei sferturi output fiindcă utilizarea reală înclină spre output; un amestec fifty-fifty clasifică modelele diferit. Workloadul de imagine presupune 1.500 output tokens, între 1.056 ai OpenAI pentru un pătrat medium și 1.584 pentru un portret medium. Video presupune cinci secunde la 1080p, iar tocmai am văzut doi furnizori schimbând locurile la 1,2 secunde. Intrarea de compute presupune șaizeci de GPU-seconds fiindcă nu există altceva de presupus.

Aceasta este metoda, și este singura onestă disponibilă: nu poți compara prețuri în unități diferite; poți compara doar costul unui workload pe care l-ai scris. Orice tabel care clasifică modele multimodale fără să își tipărească workloadul își clasifică propriile presupuneri.

Acum poți pune preț pe orice poate produce un model, în orice unitate se vinde, și poți spune cu voce tare ce workload a presupus comparația ta. Asta închide factura deschisă de Capitolul 16 și închide Partea III: totul, de la Capitolul 14 până aici, a fost despre un apel — cum îl faci, ce pui în el, cum îl eșantionezi, ce returnează, cât costă.

Capitolul 22 schimbă unitatea de analiză, iar schimbarea este scumpă. Un agent nu este un apel; este o buclă care decide singură câte apeluri să facă, iar aritmetica ultimelor două capitole este ceea ce transformă asta dintr-o diagramă de arhitectură într-un buget. Începe punând aceeași întrebare aceluiași model de două ori, cu un tool adăugat în catalog a doua oară, și măsurând ce a făcut acel singur tool: un apel a devenit două, treizeci și nouă de input tokens au devenit 420.

Dacă asta îl face agent depinde de care dintre două definiții publicate deschizi, iar ele nu sunt de acord. Una dintre ele nu este de acord cu ea însăși.

Fiecare preț, formulă și rată de conversie din acest capitol a fost citită de pe pagina proprie a furnizorului pe 7 septembrie 2026 și este citată cu acea dată, fiindcă toate se vor schimba. Numerele de tokens, costurile și comparațiile au fost calculate pe acele date de codul tipărit mai sus, pe o singură mașină, fără niciun apel API plătit — acesta fiind și motivul onest pentru care nu există nicio afirmație despre latență în acest capitol.

Funcțiile image-token, tabelele de cost, defalcarea apelului vocal și rezultatele pentru utilizare goală au fost produse de TypeScript-ul tipărit în acest capitol, rulat pe Node 22. Dialogul folosit pentru comparația vocală are 149 de cuvinte și a fost tokenizat cu tiktoken sub encodingul o200k_base la 188 tokens; durata lui rezultă dintr-un ritm declarat de 150 de cuvinte pe minut, care este un parametru al comparației și nu o măsurătoare. Fiecare cifră de furnizor poartă nota de subsol care numește pagina din care a venit.