Multimodal prissætning: Hvad billeder, lyd og video egentlig fakturerer

En transformer tager en sekvens af vektorer. Den har ingen holdning til, hvor de kom fra. Kapitel 8 fodrede den med embeddings slået op fra et token-id; intet i arkitekturen kræver opslaget.

Altså: skær billedet i faste kvadrater, flad hvert kvadrat ud til en liste af tal, og skub hver liste gennem ét indlært lineært lag for at få en vektor med modellens bredde. En 32 × 32 patch af farvepixels er $32 \times 32 \times 3 = 3072$ tal; projektionen $E \in \mathbb{R}^{d \times 3072}$ gør den til én $d$-dimensionel vektor, præcis den form et tekst-token ankommer i. Det er det hele, og det er artiklen, hvis titel siger det: et billede er 16 × 16 ord værd.¹ Tilføj en positionskodning, så modellen ved, hvilket kvadrat der lå hvor, flet resultaterne ind mellem tekst-embeddings, og den sekvens, modellen læser, er delvist billede og delvist sætning.

Tre artikler gjorde det til et produkt. CLIP trænede en billed-encoder og en tekst-encoder til at blive enige, på fire hundrede millioner scrape-de par, og dér holdt idéen om, at pixels og ord kan dele et rum, op med at være en hypotese.² Flamingo boltede en frossen vision-encoder fast på en frossen sprogmodel med nogle få trænede bro-lag.³ LLaVA viste, at broen kunne være en enkelt lineær projektion, og at instruction-following kunne læres med genererede data, hvilket er grunden til, at alle åbne vision-language-modeller siden ligner hinanden nogenlunde.⁴

Konsekvensen for din faktura er øjeblikkelig og uglamourøs: patches er positioner i sekvensen, så de er input tokens, så du betaler for dem til input-taksten. Hvor mange er aritmetik, og hver udbyder gør det forskelligt.

Hver regel nedenfor er implementeret fra udbyderens egen dokumentation og tjekket mod de gennemregnede eksempler i den samme dokumentation.

OpenAI dækker billedet med 32 × 32 patches og ganger antallet med en faktor per model. Hvis patch-antallet overstiger budgettet for den model og det detaljeniveau, skaleres billedet ned, indtil det passer:

Anthropic dækker det med 28 × 28 patches, ét visuelt token hver, og sætter loft på både den lange kant og token-antallet — 1.568 pixels og 1.568 tokens på standard-tier-modeller, 2.576 og 4.784 på high-resolution-tier. Overdimensionerede billeder skaleres til den største størrelse, der passer til begge.⁵

Google tæller slet ikke pixels. Et billede med begge sider på eller under 384 pixels koster fladt 258 tokens. Alt større skæres i tiles på 258 tokens hver, og tile-gitteret kommer fra en crop-enhed på $\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;      
}

Kør hver af dem mod de tal, dens egen leverandør trykker:

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

Ni overensstemmelser bliver printet; den fulde kørsel tjekker femten, eftersom Anthropics tabel giver begge tiers for alle seks størrelser. Reglerne er nu dine at køre på et hvilket som helst fotografi, du har, hvilket er pointen: det er de eneste tre funktioner i dette kapitel, du ikke kan få fra en prisside.

Send det samme 4:3-fotografi gennem alle tre ved seks størrelser:

Læs den sidste kolonne nedad. Når billedet først er over 384 pixels, ændrer tallet sig aldrig igen, og det er ikke et tilfælde eller et loft. Sæt crop-enheden tilbage i tile-formlen, for et billede der er mindst lige så bredt, som det er højt:

Størrelsen går ud. Googles image tokens afhænger af billedformatet og intet andet. Et 4:3-fotografi er fire tiles, uanset om det er en thumbnail eller en plakat. Den ene algebraiske kendsgerning er hele forklaringen på nullet i besparelsestabellen ovenfor, og ingen prisside nogen steder siger det.

De to andre kolonner rammer i stedet et loft, ved forskellige højder og af forskellige grunde — Anthropic ved et deklareret token-loft, OpenAI ved et patch-budget efter en pixelgrænse — og derfor krydser de tre kurver hinanden ved forskellige størrelser.

Knæk det nu. Den oplagte måde at bruge mindre på en vision-model er at bede om mindre detalje, så send detail: "low":

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

At bede om mindre detalje kostede 25 % mere. Det er ikke en fejl, og OpenAI siger det selv i én linje i størrelsestabellen: på den modelfamilie bruger low en 2048-pixelgrænse med et 6.144-patch-budget, mens high bruger samme pixelgrænse med et 2.500-patch-budget, "so it can use more tokens than high".⁷ Ordet low navngiver en fidelity-indstilling, ikke en pris: på to af de fem dokumenterede modelfamilier køber det slet ingen besparelse, og på en af de to koster det mere.

Alt hidtil har været en model, der læser et billede. At lave ét kører på en mekanisme uden tokens overhovedet, og det er grunden til, at det sælges per billede i stedet for per ord.

Leverandører offentliggør billedgenerering som en pris per billede. Det er det ikke. GPT Image-modeller udsender specialiserede image tokens, hvis antal afhænger af den ønskede størrelse og kvalitet; gang de offentliggjorte antal med GPT Image 1's offentliggjorte image output-rate på $40 per million og sammenlign med priserne per billede på samme side:

Ni afledte tal mod ni offentliggjorte, hvert par enige inden for $0.002.¹¹ Google er endnu mere eksplicit og laver konverteringen for dig på selve prissiden: image output til $60 per million tokens, "output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image".¹²

Så en pris per billede er en pris per token med antallet foldet ind. Det er fint, og det skjuler noget. Tag den nuværende generations tabel og divider baglæns:

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

Det større billede er det billigere ved hver kvalitet. Et 1024 × 1536 canvas har 50 % flere pixels end et 1024 × 1024 og koster 23 % færre tokens ved medium. OpenAI markerer det i en sætning, du ville springe over — "a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting" — og på den forrige modelgeneration gik det den anden vej, hvor portrait kostede 50 % mere end square.¹¹ Hver default på 1024x1024 skrevet før den ændring er nu den dyre mulighed.

Bed tre produkter om at sige de samme 519 tegn — cirka 38 sekunders lyd — og du får tre enhedssystemer fra to leverandører:

Den samme leverandør sælger begge enheder: OpenAIs tts-1 prissættes per million tegn, mens gpt-4o-mini-tts prissættes per million tokens, $0.60 ind og $12.00 ud.¹³ Så "billigste text-to-speech" er ikke et spørgsmål med et svar, før du siger, hvad du får sagt.

Og de to enheder er blinde for modsatte ting. En pris per tegn kan ikke se varighed: vælg en langsom, eftertænksom stemme, eller tilføj pauser, og regningen flytter sig ikke, mens lyden bliver længere. En pris per sekund kan ikke se indhold: tredive sekunder koster det samme, uanset om det er et tæt teknisk afsnit eller nogen, der tæller til ti. Skift stemmen, og præcis én af dine to leverandører omprissætter.

Transskription går den anden vej og er den enkleste linje på hele fakturaen — per minut lyd, fladt:

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)

Bemærk sidste række mod den tredje: at gøre det live, mens ordene ankommer, koster 5,7 gange at gøre det på en færdig fil. Det gab er prisen for ikke at kunne batch, og det er det, der gør næste afsnit dyrt.

Nu tallet, der afgør, om stemme er en feature eller et produkt.

Opkaldet: en support-samtale på ti turns, 149 ord, hvilket ved en deklareret hastighed på 150 ord per minut er 59,6 sekunders tale — 21,2 talt af opkalderen, 38,4 talt tilbage. Token-konverteringerne er udbydernes egne. 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 per sekund, i begge retninger, hvilket deres prisside bekræfter ved at offentliggøre $12.00 per million og $0.018 per minut på samme linje.¹²

Samtalen akkumuleres præcis som Kapitel 16 sagde, den ville, fordi det er den samme mekanisme: "the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive".¹⁴ Nu måles historikken bare i audio tokens.

Nu sammenligningen, der afgør produktet, alle fire normaliseret til et minut:

Otteogtredive gange. Ikke otteogtredive procent. Den identiske udveksling, ført i lyd i stedet for tekst, er næsten to størrelsesordener dyrere, og intet af det gab er en margin, nogen har valgt at opkræve — det er konverteringsraten. Ét sekund assistant-lyd er tyve tokens. Det samme sekund bærer 2,5 ord ved den deklarerede hastighed, og den målte transskription ligger på 1,26 tokens per ord, så som tekst er det 3,15 tokens. Lyd er en 6,3 gange mere omfangsrig pakke for samme betydning, og hver af dens tokens faktureres til 5,3 gange tekst-output-raten og 16 gange tekst-input-raten. Gang en bulk-ratio med en pris-ratio, og størrelsesordenen er der allerede, før nogen bogføring begynder.

To driftsmæssige konsekvenser falder direkte ud af tabellen.

Audio caching er ikke en optimering, det er forretningsmodellen. Cached audio input er $0.40 per million mod $32.00 fresh — en rabat på 98,75 %, der halverer opkaldet. Reglen er Kapitel 16's, uændret: cachen matcher et prefix, så alt, der indsættes forrest i samtalen midt i et opkald, ødelægger den, og det naturlige sted at placere "opkalderen er nu verificeret" er præcis dér.

Og intet du gør i klienten, af-fakturerer en lyd. Brugeren taler hen over assistenten, din kode stopper afspilningen, højttaleren bliver stille. Hvad der allerede var genereret, var allerede faktureret, fordi fakturering påløber, når responsen oprettes; og efter Kapitel 16's regel bliver hvad end der bliver i samtalen, sendt igen som input-lyd ved hvert efterfølgende turn. Kapitel 14 gjorde samme pointe om at afbryde en tekststream. I stemme koster det tredive gange mere.

Video sælges per sekund af nogle leverandører og per klip af andre, med tiers for opløsning og nogle gange for varighed. De to former adskiller sig ikke bare i bekvemmelighed; de krydser.

Per-klip-leverandøren er dyrere end per-sekund-leverandøren under 1,2 sekunder og 16,7 gange billigere ved tyve. Ingen rangordning af de to modeller overlever en ændring i kliplængde, så "hvilken videomodel er billigst" er ikke et spørgsmål om modeller.

Den sidste række er værre, og den er kapitlets ærlige kerne. mochi faktureres mod reelle GPU-sekunder — jobbets målte prediction-tid — til $0.001400 per sekund på en A100 og $0.001525 på en H100, hvilket er den lejede maskines takster og intet andet.¹⁵ Det er en fuldstændig præcis tarif, og den er ikke en pris, fordi den mængde, den ganger med, er ukendt, indtil efter du har forpligtet dig til at betale den. Rækken ovenfor antager tolv GPU-sekunder per sekund output; firedobl den antagelse, og den forlader det billigste bånd, og først ved seks gange lander den midt i tabellen. Det er den eneste tarif på denne side, du ikke kan sætte i et tilbud.

Altså: tokens, image tokens, tegn, minutter, videosekunder, hele klip, GPU-sekunder, flade enheder. Otte størrelser, og den eneste måde at lægge dem på én akse er at deklarere en workload og prissætte den.

Det er udvidelsen til Kapitel 16's computeCost — samme tier-maskineri, nu med kriterier der ikke er prompt-længde:

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

De to markerede linjer er der, hvor det knækker. En tarif angivet per enhed ganger u.images ?? 1; en tarif angivet per token ganger noget, der som default er nul. Giv begge et tomt usage — den form, du får, når en måling fejlede — og se:

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

Intet skete, seks gange, og det kostede tre dollars én gang og ingenting fem gange. Det er ikke en afrundingsforskel; det er en beslutning om, hvad et fraværende tal betyder, taget separat for hver enhed og aldrig skrevet ned. Den sunde regel er, at et felt, som ingen har målt, bliver ved med at være fraværende, fordi "ikke målt" og "målt og endte som nul" er forskellige ting. Denne funktion er stille uenig.

Den anden fejl er varighed. Den klip-prissatte tarif vælger sin tier med maxDurationSeconds mod u.videoSeconds ?? 0, så et usage, der aldrig registrerede en varighed, matcher den korteste tier:

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

Fyrre procent rabat for ikke at vide, hvor lang videoen var. Begge fejl har samme rod: en default valgt for bekvemmelighed inde i en funktion, hvis hele opgave er at være præcis.

Når omkostninger kan beregnes, kræver sammenligningen den anden halvdel — en deklareret repræsentativ workload, én per engine, angivet offentligt, så en læser kan være uenig i den:

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

Hver eneste af de linjer er et argument. Tekst blander en fjerdedel input og tre fjerdedele output, fordi reel brug hælder mod output; en fifty-fifty-blanding rangerer modellerne anderledes. Billed-workloaden antager 1.500 output tokens, mellem OpenAIs 1.056 for en medium square og dens 1.584 for en medium portrait. Video antager fem sekunder ved 1080p, og vi har lige set to leverandører bytte plads ved 1,2 sekunder. Compute-posten antager tres GPU-sekunder, fordi der ikke er andet at antage.

Det er metoden, og det er den eneste ærlige, der findes: du kan ikke sammenligne priser i forskellige enheder; du kan kun sammenligne omkostningen for en workload, du har skrevet ned. Enhver tabel, der rangerer multimodale modeller uden at trykke sin workload, rangerer sine egne antagelser.

Du kan nu prissætte alt, en model kan producere, i hvilken som helst enhed det sælges, og sige højt, hvilken workload din sammenligning antog. Det lukker den faktura, Kapitel 16 åbnede, og det lukker Del III: alt fra Kapitel 14 til her har handlet om ét kald — hvordan man laver det, hvad man putter i det, hvordan man sampler det, hvad det returnerer, hvad det koster.

Kapitel 22 ændrer analyseenheden, og ændringen er dyr. En agent er ikke ét kald; den er en løkke, der selv beslutter, hvor mange kald den vil lave, og aritmetikken fra de sidste to kapitler er det, der gør det fra et arkitekturdiagram til et budget. Det åbner med at stille samme spørgsmål til samme model to gange, med ét tool tilføjet kataloget anden gang, og måle hvad det ene tool gjorde: ét kald blev til to, niogtredive input tokens blev til 420.

Om det gør den til en agent afhænger af, hvilken af to offentliggjorte definitioner du åbner, og de er ikke enige. Den ene af dem er ikke enig med sig selv.

Hver pris, formel og konverteringsrate i dette kapitel blev læst fra udbyderens egen side den 7. september 2026 og citeres med den dato, fordi de alle vil flytte sig. Token-antal, omkostninger og sammenligninger blev beregnet på de data af koden trykt ovenfor, på én maskine, uden et betalt API-kald — hvilket også er den ærlige grund til, at der ikke er en eneste latency-påstand i dette kapitel.

Image-token-funktionerne, omkostningstabellerne, voice-call-opdelingen og empty-usage-resultaterne blev produceret af TypeScript trykt i dette kapitel, kørt på Node 22. Dialogen brugt til stemmesammenligningen er 149 ord og blev tokenized med tiktoken under o200k_base encoding ved 188 tokens; dens varighed følger af en deklareret hastighed på 150 ord per minut, hvilket er en parameter for sammenligningen og ikke en måling. Hvert leverandørtal bærer fodnoten, der navngiver den side, det kom fra.