Multimodal fiyatlandırma: Görsel, ses ve video gerçekte neyi faturalar

Bir transformer vektör dizisi alır. Bu vektörlerin nereden geldiği konusunda fikri yoktur. Chapter 8 ona bir token id’den bakılan embeddings verdi; mimaride bu lookup’ın zorunlu olduğu hiçbir şey yok.

Yani: resmi sabit karelere böl, her kareyi sayı listesine düzleştir ve her listeyi öğrenilmiş tek bir linear layer’dan geçirerek model genişliğinde bir vektör elde et. Renkli piksellerden oluşan 32 × 32 patch $32 \times 32 \times 3 = 3072$ sayıdır; projection $E \in \mathbb{R}^{d \times 3072}$ onu tek bir $d$ boyutlu vektöre çevirir; bu da bir text token’ın geldiği şeklin aynısıdır. Hepsi bu; başlığı da bunu söyleyen makale: bir görsel 16 × 16 kelime değerindedir.¹ Model hangi karenin nerede olduğunu bilsin diye positional encoding ekle, sonuçları text embeddings ile iç içe geçir; modelin okuduğu sequence artık kısmen resim, kısmen cümledir.

Üç makale bunu ürüne dönüştürdü. CLIP, dört yüz milyon scraped pair üzerinde bir image encoder ile text encoder’ı aynı şeyi söylemeye eğitti; piksellerin ve kelimelerin ortak bir uzayı paylaşabileceği fikri hipotez olmaktan orada çıktı.² Flamingo, frozen vision encoder’ı frozen language model’e birkaç eğitilmiş bridging layer ile bağladı.³ LLaVA, köprünün tek bir linear projection olabileceğini ve instruction-following’in generated data ile öğretilebileceğini gösterdi; bu yüzden o zamandan beri her open vision-language model kabaca aynı görünüyor.⁴

Faturan için sonuç anında ve gösterişsizdir: patch’ler sequence içindeki position’lardır; yani input token’dır; yani bunları input rate üzerinden ödersin. Kaç tane olduğu aritmetiktir ve her provider bunu farklı yapar.

Aşağıdaki her kural provider’ın kendi dokümantasyonundan uygulanmış ve aynı dokümantasyondaki worked example’lara karşı kontrol edilmiştir.

OpenAI görseli 32 × 32 patch’lerle kaplar ve sayıyı model başına bir katsayıyla çarpar. Patch sayısı o model ve detail level için bütçeyi aşarsa, görsel sığana kadar küçültülür:

Anthropic görseli 28 × 28 patch’lerle kaplar, her biri bir visual token’dır, ayrıca hem long edge’i hem token count’u cap’ler — standard-tier modellerde 1.568 piksel ve 1.568 token, high-resolution tier’da 2.576 ve 4.784. Fazla büyük görseller, ikisine de sığan en büyük boyuta ölçeklenir.⁵

Google piksel saymaz. İki kenarı da 384 piksel veya altında olan görsel flat 258 token tutar. Daha büyük her şey, her biri 258 token olan tile’lara bölünür ve tile grid’i $\lfloor \min(w,h) / 1.5 \rfloor$ crop unit’inden gelir.⁶

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

Her birini kendi vendor’ının yayımladığı sayılarla çalıştır:

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

Dokuz eşleşme basılır; tam run on beşini kontrol eder, çünkü Anthropic’in tablosu altı boyutun tamamı için iki tier’ı da verir. Kurallar artık herhangi bir fotoğrafın üzerinde çalıştırman için sende; mesele de bu: bu chapter’daki, price page’den alamayacağın tek üç function bunlar.

Aynı 4:3 fotoğrafı altı boyutta üçünün de içinden geçir:

Son sütunu aşağı doğru oku. Resim 384 pikseli aştığı anda sayı bir daha değişmiyor; bu tesadüf de değil, cap de değil. En az genişliği kadar yüksek olmayan bir görsel için crop unit’i tile formülüne geri koy:

Boyut sadeleşir. Google’ın image tokens’ı aspect ratio’ya bağlıdır, başka hiçbir şeye değil. 4:3 fotoğraf ister thumbnail ister poster olsun dört tile’dır. Yukarıdaki tasarruf tablosundaki sıfırın tüm açıklaması bu tek cebirsel gerçek; bunu hiçbir price page açıkça söylemez.

Diğer iki sütun ise cap’ler; farklı yüksekliklerde ve farklı sebeplerle — Anthropic beyan edilmiş token ceiling’de, OpenAI pixel limit sonrasında patch budget’ta — bu yüzden üç eğri farklı boyutlarda kesişir.

Şimdi boz. Vision modelde daha az harcamak için bariz yol daha az detail istemektir; o yüzden detail: "low" gönder:

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

Daha az detail istemek %25 daha pahalıya çıktı. Bu bug değil; OpenAI sizing table’da bunu tek satırda söylüyor: o model family’de low 2048-pixel limit ile 6.144-patch budget kullanırken high aynı pixel limit’i 2.500-patch budget ile kullanıyor, “so it can use more tokens than high”.⁷ low kelimesi price değil fidelity setting adıdır: belgelenmiş beş model family’nin ikisinde hiç tasarruf sağlamaz, o ikisinden birinde daha pahalıya gelir.

Buraya kadar her şey bir modelin görsel okumasıydı. Bir görsel yapmak içinde hiç token olmayan bir mekanizmada çalışır; bu yüzden kelime başına değil, resim başına satılır.

Vendor’lar image generation’ı resim başına fiyat olarak yayımlar. Aslında değildir. GPT Image modelleri, sayısı istenen size ve quality’ye bağlı specialised image tokens üretir; yayımlanan count’ları GPT Image 1’in yayımlanmış image output rate’i olan milyon başına $40 ile çarp ve aynı sayfadaki per-image prices ile karşılaştır:

Dokuz türetilmiş rakam, dokuz yayımlanmış rakama karşı; her çift $0.002 içinde uyuşuyor.¹¹ Google daha da açık davranıyor ve conversion’ı price page’de senin için yapıyor: image output milyon token başına $60, “output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image”.¹²

Yani per-image price, count’u içine katlanmış per-token price’tır. Bunda sorun yok; ama bir şeyi saklar. Güncel generation’ın tablosunu al ve geriye doğru böl:

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

Daha büyük görsel her quality’de daha ucuz. 1024 × 1536 canvas, 1024 × 1024’ten %50 daha fazla piksel içeriyor ve medium’da %23 daha az token tutuyor. OpenAI bunu atlayacağın bir cümlede işaretliyor — “a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting” — ve önceki model generation’da tam tersi çalışıyordu: portrait, square’den %50 daha pahalıydı.¹¹ Bu değişiklikten önce yazılmış her 1024x1024 default’u artık pahalı seçenek.

Üç üründen aynı 519 karakteri — yaklaşık 38 saniye audio — konuştur; iki vendor’dan üç unit system çıkar:

Aynı vendor iki birimi de satıyor: OpenAI’ın tts-1’i milyon karakter başına fiyatlanırken gpt-4o-mini-tts milyon token başına, $0.60 input ve $12.00 output olarak fiyatlanıyor.¹³ Yani “en ucuz text-to-speech” ne konuşturduğunu söylemeden cevaplanabilecek bir soru değil.

Ve iki birim zıt şeylere kör. Karakter başına fiyat duration’ı göremez: yavaş, tane tane bir voice seç veya pause ekle; audio uzarken fatura oynamaz. Saniye başına fiyat content’i göremez: otuz saniye ister yoğun bir teknik paragraf olsun ister birinin ona kadar sayması, aynı tutar. Voice’u değiştir, iki vendor’ından tam biri yeniden fiyatlar.

Transcription ters yönde çalışır ve tüm faturanın en basit satırıdır — audio dakika başına, flat:

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)

Son satırı üçüncüye karşı not et: işi kelimeler gelirken live yapmak, bitmiş dosyada yapmanın 5,7 katı. Bu fark batch yapamamanın fiyatıdır ve sonraki bölümü pahalı kılan da budur.

Şimdi voice’un özellik mi ürün mü olduğunu belirleyen sayı.

Call: on turn’lük bir support conversation, 149 kelime; beyan edilen 150 words per minute ile 59,6 saniye speech — 21,2’si caller’dan, 38,4’ü geri konuşulmuş. Token dönüşümleri provider’ların kendi dönüşümleri. 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: iki yönde de saniyede 25 token; bunu price page’i aynı satırda $12.00 per million ve $0.018 per minute yayımlayarak doğruluyor.¹²

Conversation tam Chapter 16’nın söylediği gibi birikir, çünkü mekanizma aynıdır: “the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive”.¹⁴ Tek fark, history’nin artık audio tokens ile ölçülmesi.

Şimdi ürünü belirleyen karşılaştırma; dört satır da bir dakikaya normalize edilmiş:

Otuz sekiz kat. Otuz sekiz per cent değil. Ses yerine metinle yapılan aynı exchange neredeyse iki order of magnitude daha pahalı ve bu farkın hiçbiri birinin koymayı seçtiği margin değil — conversion rate. Bir saniye assistant audio yirmi token’dır. Aynı saniye beyan edilen rate’te 2,5 kelime taşır ve measured transcript kelime başına 1,26 token’dır; yani text olarak 3,15 token. Sound aynı meaning için 6,3 kat daha hacimli bir paket; ayrıca token’larının her biri text output rate’in 5,3 katı ve text input rate’in 16 katı üzerinden faturalandırılır. Bulk ratio’yu price ratio ile çarp; muhasebe başlamadan order of magnitude zaten oradadır.

Tablodan iki operational sonuç doğrudan çıkar.

Audio caching optimizasyon değil, business model’dir. Cached audio input milyon başına $0.40, fresh ise $32.00 — call’u yarıya indiren %98,75 discount. Kural Chapter 16’nınkiyle aynı: cache bir prefix eşleşmesi arar; dolayısıyla call ortasında conversation’ın başına eklenen her şey onu bozar ve “caller artık verified” bilgisini koymanın doğal yeri tam da orasıdır.

Client’ta yaptığın hiçbir şey sesi faturadan düşürmez. User assistant’ın üstüne konuşur, kodun playback’i durdurur, speaker susar. Üretilmiş olan ne varsa zaten charge edilmiştir, çünkü billing response oluşturulduğunda accrue eder; Chapter 16’nın kuralıyla, conversation’da kalan her şey sonraki her turn’de input audio olarak yeniden gönderilir. Chapter 14 bunu text stream’i abort etmek için söyledi. Voice’ta otuz kat daha pahalıdır.

Video bazı vendor’larda saniye başına, bazılarında clip başına satılır; resolution ve bazen duration için tier’lar vardır. Bu iki shape yalnızca convenience açısından farklı değildir; kesişirler.

Clip başına satan vendor, 1,2 saniyenin altında saniye başına satandan pahalı; yirmi saniyede 16,7 kat ucuz. Bu iki modelin sıralaması clip length değişince ayakta kalmaz; yani “hangi video modeli en ucuz” model hakkında bir soru değildir.

Son satır daha kötü ve bu chapter’ın dürüst kalbi orası. mochi real GPU seconds üzerinden faturalanır — job’ın measured prediction time’ı — A100’de saniye başına $0.001400, H100’de $0.001525; bunlar kiralanan makinenin rate’leridir, başka bir şey değil.¹⁵ Bu tamamen precise bir tariff’tır ve price değildir, çünkü çarptığı quantity ödemeyi kabul ettikten sonra belli olur. Yukarıdaki satır output’un her saniyesi için on iki GPU-second varsayar; bu varsayımı dörtle çarp, en ucuz band’dan çıkar; ancak altı katında tablonun ortasına iner. Bu sayfadaki, quote’a koyamayacağın tek tariff budur.

Yani: tokens, image tokens, characters, minutes, video seconds, whole clips, GPU seconds, flat units. Sekiz quantity ve bunları tek eksene koymanın tek yolu bir workload beyan edip onu fiyatlamaktır.

Bu, Chapter 16’nın computeCost uzantısıdır — aynı tier machinery, artık prompt length olmayan criteria ile:

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

İşaretli iki satır kırıldığı yer. Unit başına quoted tariff u.images ?? 1 ile çarpılır; token başına quoted tariff default’u sıfır olan bir şeyle çarpılır. İkisine de empty usage ver — measurement fail olduğunda aldığın shape — ve izle:

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

Altı kez hiçbir şey olmadı; birinde üç dolar tuttu, beşinde hiçbir şey tutmadı. Bu rounding difference değil; eksik bir sayının ne anlama geldiği hakkında, her unit için ayrı alınmış ve hiçbir yerde yazılmamış bir karar. Sağlam kural, kimsenin ölçmediği bir field’ın absent kalmasıdır, çünkü “ölçülmedi” ile “ölçüldü ve sıfır çıktı” farklı şeylerdir. Bu fonksiyon sessizce buna katılmıyor.

İkinci failure duration. Clip-priced tariff tier’ını maxDurationSeconds ile u.videoSeconds ?? 0’ye karşı seçiyor; yani duration kaydetmemiş usage en kısa tier ile eşleşiyor:

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

Videonun ne kadar sürdüğünü bilmediğin için yüzde kırk indirim. İki bug’ın root’u aynı: işi exact olmak olan bir function’ın içinde convenience için seçilmiş default.

Cost’lar computable olduğuna göre karşılaştırmanın diğer yarısı gerekir — engine başına bir tane, kamuya açık ifade edilen, okuyucunun itiraz edebileceği declared representative workload:

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

Bu satırların her biri bir argümandır. Text dörtte bir input, dörtte üç output karıştırır çünkü gerçek usage output’a kayar; fifty-fifty blend modelleri farklı sıralar. Image workload, OpenAI’ın medium square için 1.056’sı ile medium portrait için 1.584’ü arasında, 1.500 output token varsayar. Video beş saniye 1080p varsayar; az önce iki vendor’ın 1,2 saniyede yer değiştirdiğini gördük. Compute entry altmış GPU-second varsayar çünkü varsayacak başka hiçbir şey yok.

Yöntem budur ve eldeki tek dürüst yöntem de budur: farklı unit’lerdeki price’ları karşılaştıramazsın; yalnızca yazıya döktüğün bir workload’un cost’unu karşılaştırabilirsin. Workload’unu basmadan multimodal modelleri sıralayan her tablo, kendi assumptions’ını sıralıyordur.

Artık bir modelin üretebildiği her şeyi, hangi unit’te satılırsa satılsın fiyatlayabilir ve comparison’ın hangi workload’u varsaydığını yüksek sesle söyleyebilirsin. Bu, Chapter 16’nın açtığı faturayı kapatır ve Part III’ü kapatır: Chapter 14’ten buraya kadar her şey one call hakkındaydı — onu nasıl yaparsın, içine ne koyarsın, nasıl sample edersin, ne döndürür, ne tutar.

Chapter 22 analysis unit’ini değiştiriyor ve değişiklik pahalı. Bir agent tek call değildir; kaç call yapacağına kendi karar veren bir loop’tur ve son iki chapter’ın aritmetiği onu architecture diagram’dan bütçeye dönüştürür. Aynı modele aynı soruyu iki kez sorarak açılır; ikinci sefer catalogue’a bir tool eklenir ve o tek tool’un ne yaptığı ölçülür: bir call iki oldu, otuz dokuz input token 420 oldu.

Bunun agent sayılıp sayılmayacağı, yayımlanmış iki definition’dan hangisini açtığına bağlı; onlar da aynı fikirde değil. Bir tanesi kendi içinde de aynı fikirde değil.

Bu chapter’daki her price, formula ve conversion rate provider’ın kendi sayfasından 7 Eylül 2026 tarihinde okundu ve o tarihle quoted edildi; çünkü hepsi değişecek. Token count’ları, cost’lar ve comparison’lar yukarıda basılan code ile, tek bir makinede, paid API call yapılmadan hesaplandı — bu chapter’da tek bir latency claim olmamasının dürüst nedeni de budur.

Image-token function’ları, cost table’ları, voice-call breakdown ve empty-usage results bu chapter’da basılan TypeScript ile, Node 22 üzerinde çalıştırılarak üretildi. Voice comparison’da kullanılan dialogue 149 kelimedir ve o200k_base encoding altında tiktoken ile 188 token olarak tokenized edildi; duration’ı, comparison’ın parameter’ı olan ve measurement olmayan 150 words per minute declared rate’ten gelir. Her provider figure, geldiği page’i adlandıran footnote’u taşır.