Harga Multimodal: Tagihan Nyata untuk Gambar, Audio, dan Video

Transformer menerima urutan vektor. Ia tidak peduli dari mana vektor itu berasal. Bab 8 memberinya embeddings yang diambil dari token id; tidak ada dalam arsitektur yang mengharuskan lookup itu.

Jadi: potong gambar menjadi kotak-kotak tetap, ratakan tiap kotak menjadi daftar angka, lalu dorong tiap daftar melalui satu layer linear terpelajar untuk mendapatkan vektor selebar model. Patch piksel warna 32 × 32 adalah $32 \times 32 \times 3 = 3072$ angka; proyeksi $E \in \mathbb{R}^{d \times 3072}$ mengubahnya menjadi satu vektor berdimensi $d$, persis bentuk sebuah text token saat masuk. Itu saja seluruhnya, dan paper yang judulnya mengatakannya: sebuah gambar bernilai 16 × 16 kata.¹ Tambahkan positional encoding agar model tahu kotak mana berada di mana, selang-selingkan hasilnya dengan text embeddings, dan urutan yang dibaca model menjadi sebagian gambar dan sebagian kalimat.

Tiga paper membuatnya menjadi produk. CLIP melatih image encoder dan text encoder agar sepakat, pada empat ratus juta pasangan hasil scrape, dan di sanalah gagasan bahwa piksel dan kata bisa berbagi ruang berhenti menjadi hipotesis.² Flamingo memasang vision encoder beku ke language model beku dengan beberapa bridging layer terlatih.³ LLaVA menunjukkan bridge itu bisa berupa satu proyeksi linear dan instruction-following bisa diajarkan dengan data yang dihasilkan, sebab itu setiap open vision-language model sejak saat itu terlihat kira-kira sama.⁴

Konsekuensinya untuk invoice kamu langsung dan tidak glamor: patch adalah posisi dalam urutan, jadi patch adalah input tokens, jadi kamu membayarnya dengan tarif input. Berapa banyaknya adalah aritmetika, dan tiap provider melakukannya secara berbeda.

Setiap aturan di bawah diimplementasikan dari dokumentasi provider sendiri dan dicek terhadap contoh kerja di dokumentasi yang sama.

OpenAI menutupi gambar dengan patch 32 × 32 dan mengalikan hitungannya dengan faktor per model. Jika jumlah patch melampaui anggaran untuk model dan level detail itu, gambar diperkecil sampai muat:

Anthropic menutupinya dengan patch 28 × 28, satu visual token masing-masing, dan memberi cap pada sisi panjang serta jumlah token — 1.568 piksel dan 1.568 tokens pada model standard-tier, 2.576 dan 4.784 pada high-resolution tier. Gambar yang terlalu besar diskalakan ke ukuran terbesar yang memenuhi keduanya.⁵

Google sama sekali tidak menghitung piksel. Gambar dengan kedua sisi 384 piksel atau kurang dikenai tarif datar 258 tokens. Apa pun yang lebih besar dipotong menjadi tile masing-masing 258 tokens, dan grid tile berasal dari crop unit sebesar $\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;      
}

Jalankan masing-masing terhadap angka yang dicetak vendornya sendiri:

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

Sembilan kecocokan dicetak; run penuh mengecek lima belas, karena tabel Anthropic memberi kedua tier untuk keenam ukuran. Aturan itu sekarang bisa kamu jalankan pada foto apa pun yang kamu punya, dan itulah intinya: inilah satu-satunya tiga functions dalam bab ini yang tidak bisa kamu dapatkan dari halaman harga.

Masukkan foto 4:3 yang sama melalui ketiganya pada enam ukuran:

Baca kolom terakhir ke bawah. Begitu gambar melewati 384 piksel, angkanya tidak pernah berubah lagi, dan itu bukan kebetulan atau cap. Substitusikan crop unit kembali ke formula tile, untuk gambar yang setidaknya selebar tingginya:

Ukurannya saling hapus. Image tokens Google bergantung pada aspect ratio dan tidak pada yang lain. Foto 4:3 adalah empat tile, entah ia thumbnail atau poster. Fakta aljabar tunggal itu adalah seluruh penjelasan untuk angka nol di tabel penghematan di atas, dan tidak ada halaman harga mana pun yang menyatakannya.

Dua kolom lain justru melakukan cap, pada tinggi berbeda dan dengan alasan berbeda — Anthropic pada ceiling token yang dinyatakan, OpenAI pada patch budget setelah limit piksel — dan itulah mengapa tiga kurva berpotongan pada ukuran yang berbeda.

Sekarang rusakkan. Cara yang jelas untuk membayar lebih sedikit pada vision model adalah meminta detail lebih sedikit, jadi kirim detail: "low":

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

Meminta detail lebih sedikit malah berbiaya 25 % lebih mahal. Ini bukan bug dan OpenAI mengatakannya dalam satu baris tabel sizing: pada keluarga model itu, low menggunakan limit 2048-piksel dengan budget 6.144-patch sementara high menggunakan limit piksel yang sama dengan budget 2.500-patch, “so it can use more tokens than high”.⁷ Kata low menamai pengaturan fidelity, bukan harga: pada dua dari lima keluarga model yang didokumentasikan ia tidak memberi penghematan sama sekali, dan pada salah satu dari dua itu biayanya lebih mahal.

Semua sejauh ini adalah model yang membaca gambar. Membuat gambar berjalan pada mekanisme yang sama sekali tidak memiliki tokens, dan itulah alasan ia dijual per gambar, bukan per kata.

Vendor mempublikasikan image generation sebagai harga per gambar. Itu bukan satu harga tunggal. Model GPT Image mengeluarkan image tokens khusus yang jumlahnya bergantung pada ukuran dan kualitas yang diminta; kalikan jumlah yang dipublikasikan dengan tarif output gambar GPT Image 1 yang dipublikasikan sebesar $40 per juta dan bandingkan dengan harga per gambar di halaman yang sama:

Sembilan angka turunan melawan sembilan angka yang dipublikasikan, setiap pasangan cocok dalam selisih $0.002.¹¹ Google bahkan lebih eksplisit dan melakukan konversinya untukmu di halaman harga itu sendiri: output gambar pada $60 per juta tokens, “output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image”.¹²

Jadi harga per gambar adalah harga per token dengan hitungannya dilipat masuk. Itu baik-baik saja, dan menyembunyikan sesuatu. Ambil tabel generasi saat ini dan bagi mundur:

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

Gambar yang lebih besar adalah yang lebih murah pada setiap quality. Canvas 1024 × 1536 memiliki 50 % lebih banyak piksel daripada 1024 × 1024 dan berbiaya 23 % lebih sedikit tokens pada medium. OpenAI menandainya dalam satu kalimat yang mungkin kamu lewati — “a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting” — dan pada generasi model sebelumnya arahnya terbalik, portrait berbiaya 50 % lebih mahal daripada square.¹¹ Setiap default 1024x1024 yang ditulis sebelum perubahan itu sekarang menjadi opsi mahal.

Minta tiga produk mengucapkan 519 karakter yang sama — sekitar 38 detik audio — dan kamu mendapat tiga sistem unit dari dua vendor:

Vendor yang sama menjual kedua unit: tts-1 milik OpenAI dihargai per juta karakter sementara gpt-4o-mini-tts dihargai per juta tokens, $0.60 masuk dan $12.00 keluar.¹³ Jadi “text-to-speech termurah” bukan pertanyaan yang punya jawaban sampai kamu mengatakan apa yang diucapkan.

Dan kedua unit itu buta terhadap hal yang berlawanan. Harga per karakter tidak bisa melihat durasi: pilih suara yang lambat dan deliberatif, atau tambahkan jeda, dan tagihannya tidak bergerak sementara audionya makin panjang. Harga per detik tidak bisa melihat konten: tiga puluh detik biayanya sama entah itu paragraf teknis yang padat atau seseorang menghitung sampai sepuluh. Ganti suaranya dan tepat satu dari dua vendormu menghitung ulang harga.

Transkripsi berjalan sebaliknya dan menjadi baris paling sederhana di seluruh invoice — per menit audio, datar:

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)

Perhatikan baris terakhir dibanding baris ketiga: melakukannya live, saat kata-kata datang, biayanya 5,7 kali dibanding melakukannya pada file yang sudah selesai. Selisih itu adalah harga karena tidak bisa melakukan batch, dan itulah yang membuat bagian berikutnya mahal.

Sekarang angka yang menentukan apakah voice adalah fitur atau produk.

Panggilannya: percakapan dukungan sepuluh turn, 149 kata, yang pada 150 kata per menit yang dinyatakan adalah 59,6 detik ujaran — 21,2 diucapkan oleh penelepon, 38,4 diucapkan kembali. Konversi token adalah milik provider sendiri. 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 detik, dua arah, yang dikonfirmasi halaman harganya dengan mempublikasikan $12.00 per juta dan $0.018 per menit pada baris yang sama.¹²

Percakapan terakumulasi persis seperti yang dikatakan Bab 16, karena mekanismenya sama: “the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive”.¹⁴ Hanya saja sekarang history diukur dalam audio tokens.

Sekarang perbandingan yang menentukan produk, keempatnya dinormalisasi ke satu menit:

Tiga puluh delapan kali. Bukan tiga puluh delapan persen. Pertukaran yang identik, dilakukan dalam suara alih-alih teks, hampir dua orde magnitudo lebih mahal, dan tidak satu pun dari selisih itu adalah margin yang sengaja dikenakan seseorang — itu adalah rasio konversi. Satu detik audio assistant adalah dua puluh tokens. Detik yang sama membawa 2,5 kata pada laju yang dinyatakan, dan transkrip terukur berjalan pada 1,26 tokens per kata, jadi sebagai teks ia 3,15 tokens. Suara adalah paket 6,3 kali lebih besar untuk makna yang sama, dan setiap token-nya ditagihkan pada 5,3 kali tarif output teks dan 16 kali tarif input teks. Kalikan rasio bulk dengan rasio harga dan orde magnitudonya sudah muncul bahkan sebelum akuntansi dimulai.

Dua konsekuensi operasional langsung keluar dari tabel.

Audio caching bukan optimisasi, melainkan business model. Cached audio input adalah $0.40 per juta melawan $32.00 fresh — diskon 98,75 % yang memangkas panggilan menjadi separuh. Aturannya sama seperti Bab 16, tidak berubah: cache mencocokkan prefix, jadi apa pun yang disisipkan di depan percakapan di tengah panggilan menghancurkannya, dan tempat alami untuk menaruh “penelepon sekarang terverifikasi” persis di sana.

Dan tidak ada yang kamu lakukan di client yang membatalkan tagihan suara. User berbicara menindih assistant, kode kamu menghentikan playback, speaker menjadi senyap. Apa pun yang sudah dihasilkan sudah ditagihkan, karena billing bertambah saat response dibuat; dan menurut aturan Bab 16, apa pun yang tetap berada dalam percakapan dikirim ulang, sebagai input audio, di setiap turn setelahnya. Bab 14 membuat poin ini tentang membatalkan text stream. Dalam voice, biayanya tiga puluh kali lebih mahal.

Video dijual per detik oleh sebagian vendor dan per clip oleh yang lain, dengan tier untuk resolusi dan kadang untuk durasi. Dua bentuk itu bukan sekadar berbeda dalam kenyamanan; keduanya berpotongan.

Vendor per-clip lebih mahal daripada vendor per-second di bawah 1,2 detik dan 16,7 kali lebih murah pada dua puluh detik. Tidak ada urutan dari dua model itu yang bertahan setelah panjang clip berubah, jadi “model video mana yang termurah” bukan pertanyaan tentang model.

Baris terakhir lebih buruk, dan itulah inti jujur bab ini. mochi ditagihkan terhadap detik GPU nyata — waktu prediksi terukur dari job — pada $0.001400 per detik di A100 dan $0.001525 di H100, yang merupakan tarif mesin sewaan dan tidak lebih.¹⁵ Itu tarif yang sepenuhnya presisi dan bukan harga, karena kuantitas yang dikalikannya tidak diketahui sampai setelah kamu berkomitmen untuk membayarnya. Baris di atas mengasumsikan dua belas GPU-seconds per detik output; lipatgandakan asumsi itu empat kali dan ia keluar dari band termurah, dan baru pada enam kali ia mendarat di tengah tabel. Itu satu-satunya tarif di halaman ini yang tidak bisa kamu masukkan ke quote.

Jadi: tokens, image tokens, karakter, menit, detik video, seluruh clip, GPU seconds, unit datar. Delapan kuantitas, dan satu-satunya cara menaruhnya pada satu sumbu adalah menyatakan workload lalu menghargainya.

Itulah ekstensi untuk computeCost dari Bab 16 — machinery tier yang sama, sekarang dengan criteria yang bukan panjang 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;
}

Dua baris yang ditandai adalah tempat ia pecah. Tarif yang dikutip per unit mengalikan u.images ?? 1; tarif yang dikutip per token mengalikan sesuatu yang default-nya nol. Beri keduanya usage kosong — bentuk yang kamu dapat saat measurement gagal — dan lihat:

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

Tidak terjadi apa-apa, enam kali, dan biayanya tiga dolar sekali serta nol lima kali. Itu bukan selisih pembulatan; itu keputusan tentang arti angka yang absen, diambil terpisah untuk tiap unit dan tidak pernah dituliskan. Aturan yang benar adalah field yang tidak diukur siapa pun tetap absen, karena “not measured” dan “measured and came out zero” adalah hal berbeda. Fungsi ini diam-diam tidak setuju.

Kegagalan kedua adalah durasi. Tarif clip-priced memilih tier-nya dengan maxDurationSeconds terhadap u.videoSeconds ?? 0, jadi usage yang tidak pernah mencatat durasi cocok dengan tier terpendek:

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

Diskon empat puluh persen karena tidak tahu berapa lama videonya. Kedua bug punya akar yang sama: default yang dipilih demi kenyamanan di dalam function yang seluruh tugasnya adalah presisi.

Dengan biaya bisa dihitung, perbandingan membutuhkan separuh lainnya — declared representative workload, satu per engine, dinyatakan di publik agar pembaca bisa tidak setuju dengannya:

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

Setiap baris itu adalah argumen. Teks mencampur seperempat input dan tiga perempat output karena pemakaian nyata condong ke output; blend lima puluh-lima puluh akan memberi ranking model berbeda. Workload gambar mengasumsikan 1.500 output tokens, di antara 1.056 milik OpenAI untuk medium square dan 1.584 untuk medium portrait. Video mengasumsikan lima detik pada 1080p, dan kita baru saja melihat dua vendor bertukar tempat pada 1,2 detik. Entri compute mengasumsikan enam puluh GPU-seconds karena tidak ada hal lain untuk diasumsikan.

Itulah metodenya, dan itu satu-satunya metode jujur yang tersedia: kamu tidak bisa membandingkan harga dalam unit berbeda; kamu hanya bisa membandingkan biaya workload yang sudah kamu tuliskan. Tabel apa pun yang memberi ranking model multimodal tanpa mencetak workload-nya sedang memberi ranking pada asumsi-asumsinya sendiri.

Sekarang kamu bisa menghargai apa pun yang bisa dihasilkan model, dalam unit apa pun yang dijual, dan menyebutkan dengan jelas workload mana yang diasumsikan perbandinganmu. Itu menutup invoice yang dibuka Bab 16, dan menutup Part III: semua dari Bab 14 sampai sini membahas satu call — cara membuatnya, apa yang dimasukkan, cara melakukan sample, apa yang dikembalikan, berapa biayanya.

Bab 22 mengubah unit analisis, dan perubahan itu mahal. Agent bukan satu call; ia adalah loop yang memutuskan sendiri berapa banyak call yang akan dibuat, dan aritmetika dua bab terakhir adalah yang mengubahnya dari diagram arsitektur menjadi anggaran. Bab itu dibuka dengan mengajukan pertanyaan yang sama kepada model yang sama dua kali, dengan satu tool ditambahkan ke katalog pada kali kedua, dan mengukur apa yang dilakukan satu tool itu: satu call menjadi dua, tiga puluh sembilan input tokens menjadi 420.

Apakah itu menjadikannya agent bergantung pada definisi terpublikasi mana dari dua definisi yang kamu buka, dan keduanya tidak sepakat. Salah satunya bahkan tidak sepakat dengan dirinya sendiri.

Setiap harga, formula, dan conversion rate dalam bab ini dibaca dari halaman provider sendiri pada 7 September 2026 dan dikutip dengan tanggal itu, karena semuanya akan berubah. Hitungan token, biaya, dan perbandingan dihitung pada data itu oleh kode yang dicetak di atas, pada satu mesin, tanpa paid API call — yang juga menjadi alasan jujur mengapa tidak ada satu pun klaim latency dalam bab ini.

Functions image-token, tabel biaya, rincian voice-call, dan hasil empty-usage dihasilkan oleh TypeScript yang dicetak dalam bab ini, dijalankan di Node 22. Dialog yang digunakan untuk perbandingan voice berjumlah 149 kata dan di-tokenize dengan tiktoken di bawah encoding o200k_base pada 188 tokens; durasinya berasal dari laju yang dinyatakan sebesar 150 kata per menit, yang merupakan parameter perbandingan dan bukan measurement. Setiap angka provider membawa footnote yang menamai halaman asalnya.