Мультимодальне ціноутворення: за що насправді рахують зображення, аудіо та відео

transformer приймає послідовність векторів. Йому байдуже, звідки вони взялися. У Розділі 8 ми подавали йому embeddings, знайдені за token id; в архітектурі немає вимоги, щоб це був саме lookup.

Отже: розріжте картинку на фіксовані квадрати, розгорніть кожен квадрат у список чисел і пропустіть кожен список через один навчений лінійний шар, щоб отримати вектор ширини моделі. Патч кольорових пікселів 32 × 32 — це $32 \times 32 \times 3 = 3072$ чисел; проєкція $E \in \mathbb{R}^{d \times 3072}$ перетворює його на один $d$-вимірний вектор, точно такої форми, у якій приходить текстовий token. Ось і все, і це саме та стаття, назва якої каже: зображення варте 16 × 16 слів.¹ Додайте positional encoding, щоб модель знала, який квадрат де був, перемішайте результати з текстовими embeddings — і послідовність, яку читає модель, стає частково картинкою, частково реченням.

Три статті зробили це продуктом. CLIP навчила image encoder і text encoder узгоджуватися на чотирьохстах мільйонах зібраних пар, і саме там ідея, що пікселі та слова можуть мати спільний простір, перестала бути гіпотезою.² Flamingo прикрутив заморожений vision encoder до замороженої мовної моделі кількома навченими містками.³ LLaVA показала, що містком може бути одна лінійна проєкція, а instruction-following можна навчити на згенерованих даних, тому всі відкриті vision-language моделі відтоді виглядають приблизно однаково.⁴

Наслідок для вашого інвойсу негайний і непривабливий: патчі — це позиції в послідовності, отже вони є input tokens, отже ви платите за них за вхідною ставкою. Скільки саме — арифметика, і кожен постачальник робить її по-своєму.

Кожне правило нижче реалізоване з власної документації постачальника й перевірене на прикладах із тієї самої документації.

OpenAI покриває зображення патчами 32 × 32 і множить кількість на коефіцієнт конкретної моделі. Якщо кількість патчів перевищує бюджет для цієї моделі й рівня деталізації, зображення зменшують, доки воно не вміститься:

Anthropic покриває його патчами 28 × 28, по одному visual token кожен, і обмежує як довгий бік, так і кількість tokens — 1,568 пікселів і 1,568 tokens на моделях standard-tier, 2,576 і 4,784 на high-resolution tier. Надто великі зображення масштабуються до найбільшого розміру, який відповідає обом обмеженням.⁵

Google узагалі не рахує пікселі. Зображення, у якого обидві сторони не перевищують 384 пікселі, коштує фіксовані 258 tokens. Усе більше ріжеться на tiles по 258 tokens кожен, а сітка tiles походить із crop unit $\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;      
}

Запустіть кожне правило на числах, які друкує його власний постачальник:

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

Друкується дев’ять збігів; повний запуск перевіряє п’ятнадцять, бо таблиця Anthropic дає обидва рівні для всіх шести розмірів. Тепер ці правила ваші, і ви можете запускати їх на будь-якій фотографії. У цьому й сенс: це єдині три функції в цьому розділі, яких ви не отримаєте зі сторінки цін.

Пропустіть ту саму фотографію 4:3 через усі три правила у шести розмірах:

Прочитайте останній стовпець зверху вниз. Щойно картинка більша за 384 пікселі, число більше ніколи не змінюється, і це не збіг і не cap. Підставте crop unit назад у формулу tile для зображення, яке принаймні таке широке, як високе:

Розмір скорочується. Google image tokens залежать від aspect ratio і більше ні від чого. Фотографія 4:3 — це чотири tiles, чи вона мініатюра, чи постер. Один цей алгебраїчний факт повністю пояснює нуль у таблиці економії вище, і жодна сторінка цін ніде цього не формулює.

Два інші стовпці натомість обмежуються, на різних висотах і з різних причин — Anthropic на оголошеній стелі tokens, OpenAI на patch budget після pixel limit — тому три криві перетинаються на різних розмірах.

Тепер зламайте це. Очевидний спосіб витратити менше на vision model — попросити менше деталей, тож надішліть detail: "low":

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

Попросити менше деталей коштувало на 25 % більше. Це не баг, і OpenAI каже про це одним рядком у таблиці розмірів: у цій сім’ї моделей low використовує 2048-піксельний ліміт із 6,144-patch budget, тоді як high використовує той самий pixel limit із 2,500-patch budget, «so it can use more tokens than high».⁷ Слово low означає налаштування fidelity, а не ціну: у двох із п’яти задокументованих сімейств моделей воно взагалі не дає економії, а в одному з цих двох коштує дорожче.

Усе досі стосувалося моделі, яка читає зображення. Створення зображення працює на механізмі, у якому взагалі немає tokens, і саме тому воно продається за картинку, а не за слово.

Постачальники публікують генерацію зображень як ціну за картинку. Це не так. GPT Image models випускають спеціалізовані image tokens, кількість яких залежить від потрібного розміру та якості; помножте опубліковані кількості на опубліковану ставку GPT Image 1 для image output — $40 за мільйон — і порівняйте з per-image цінами на тій самій сторінці:

Дев’ять виведених чисел проти дев’яти опублікованих, кожна пара збігається в межах $0.002.¹¹ Google ще явніший і сам робить конверсію на сторінці цін: image output по $60 за мільйон tokens, «output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image».¹²

Тож per-image price — це per-token price із уже вкладеною кількістю. Це нормально, але дещо приховує. Візьміть таблицю поточного покоління й поділіть у зворотному напрямку:

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

Більше зображення є дешевшим за кожного рівня якості. Полотно 1024 × 1536 має на 50 % більше пікселів, ніж 1024 × 1024, і коштує на 23 % менше tokens на medium. OpenAI позначає це реченням, яке ви пропустили б: «a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting» — а в попередньому поколінні моделей усе було навпаки, портрет коштував на 50 % більше, ніж квадрат.¹¹ Кожний default 1024x1024, написаний до цієї зміни, тепер є дорогим варіантом.

Попросіть три продукти озвучити ті самі 519 символів — близько 38 секунд аудіо — і отримаєте три системи одиниць від двох постачальників:

Той самий постачальник продає обидві одиниці: tts-1 від OpenAI оцінюється за мільйон символів, тоді як gpt-4o-mini-tts — за мільйон tokens, $0.60 in і $12.00 out.¹³ Тож «найдешевший text-to-speech» — це не питання з відповіддю, доки ви не скажете, що саме озвучуєте.

І ці дві одиниці сліпі до протилежних речей. Ціна за символ не бачить тривалість: оберіть повільний, виразний голос або додайте паузи — рахунок не зміниться, хоча аудіо стане довшим. Ціна за секунду не бачить зміст: тридцять секунд коштують однаково, чи це щільний технічний абзац, чи хтось рахує до десяти. Змініть голос — і рівно один із двох постачальників перераховує ціну.

Транскрипція працює навпаки й є найпростішим рядком у всьому інвойсі — за хвилину аудіо, фіксовано:

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)

Зверніть увагу на останній рядок проти третього: робити це наживо, коли слова надходять, коштує в 5.7 раза більше, ніж робити це на готовому файлі. Ця різниця — ціна неможливості batch, і саме вона робить наступний розділ дорогим.

Тепер число, яке вирішує, чи голос — це функція, чи продукт.

Дзвінок: десятираундова розмова підтримки, 149 слів, що за оголошених 150 слів на хвилину становить 59.6 секунди мовлення — 21.2 сказано абонентом, 38.4 сказано у відповідь. Конверсії tokens — власні конверсії постачальників. 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 за секунду в обох напрямках, що підтверджує її сторінка цін, публікуючи $12.00 за мільйон і $0.018 за хвилину в одному рядку.¹²

Розмова накопичується саме так, як казав Розділ 16, бо механізм той самий: «the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive».¹⁴ Тільки тепер історія вимірюється в audio tokens.

Тепер порівняння, яке вирішує продукт, усі чотири нормалізовані до хвилини:

Тридцять вісім разів. Не тридцять вісім відсотків. Ідентичний обмін, проведений звуком замість тексту, майже на два порядки дорожчий, і жодна частина цього розриву не є маржею, яку хтось вирішив нарахувати, — це conversion rate. Одна секунда assistant audio — це двадцять tokens. Та сама секунда несе 2.5 слова за оголошеною швидкістю, а виміряний transcript має 1.26 tokens на слово, тож як текст це 3.15 tokens. Звук — у 6.3 раза громіздкіший пакет для того самого змісту, і кожен його token тарифікується у 5.3 раза дорожче за text output rate і в 16 разів дорожче за text input rate. Помножте bulk ratio на price ratio — і порядок величини вже є ще до будь-якого обліку.

Два операційні наслідки прямо випливають із таблиці.

Audio caching — не оптимізація, а бізнес-модель. Cached audio input коштує $0.40 за мільйон проти $32.00 fresh — знижка 98.75 %, яка вдвічі здешевлює дзвінок. Правило з Розділу 16 незмінне: cache збігається з prefix, тож будь-що, вставлене на початок розмови посеред дзвінка, руйнує його, а природне місце для «caller is now verified» — саме там.

І ніщо, що ви робите в клієнті, не скасовує оплату звуку. Користувач перебиває assistant, ваш код зупиняє відтворення, динамік стихає. Усе, що вже було згенеровано, уже було нараховано, бо billing accrues when the response is created; і за правилом Розділу 16 усе, що лишається в розмові, повторно надсилається як input audio на кожному наступному turn. Розділ 14 казав це про aborting text stream. У голосі це коштує у тридцять разів більше.

Відео одні постачальники продають за секунду, інші — за clip, з рівнями для роздільності й іноді тривалості. Ці дві форми відрізняються не лише зручністю; вони перетинаються.

Постачальник із per-clip дорожчий за per-second нижче 1.2 секунди й у 16.7 раза дешевший на двадцяти. Жодне ранжування цих двох моделей не переживає зміни довжини clip, тож «яка video model найдешевша» — не питання про моделі.

Останній рядок гірший, і це чесне серце розділу. mochi тарифікується за реальні GPU seconds — виміряний prediction time завдання — по $0.001400 за секунду на A100 і $0.001525 на H100, тобто це ставки орендованої машини й нічого більше.¹⁵ Це абсолютно точний тариф, але це не ціна, бо величина, на яку він множиться, невідома, доки ви вже не погодилися платити. Рядок вище припускає дванадцять GPU-seconds на секунду output; збільште це припущення вчетверо — і він виходить із найдешевшої смуги, а лише при шестикратному множнику опиняється в середині таблиці. Це єдиний тариф на цій сторінці, який не можна поставити в quote.

Отже: tokens, image tokens, characters, minutes, video seconds, whole clips, GPU seconds, flat units. Вісім величин, і єдиний спосіб поставити їх на одну вісь — оголосити workload і порахувати його.

Це розширення computeCost з Розділу 16 — той самий tier-механізм, тепер із критеріями, які не є довжиною 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;
}

Два позначені рядки — місце, де все ламається. Тариф, заданий за unit, множить u.images ?? 1; тариф, заданий за token, множить щось, що за замовчуванням дорівнює нулю. Подайте обом порожнє usage — форму, яку отримуєте, коли measurement failed, — і подивіться:

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

Нічого не сталося, шість разів, і один раз це коштувало три долари, а п’ять разів нічого. Це не різниця округлення; це рішення про те, що означає відсутнє число, прийняте окремо для кожної одиниці й ніде не записане. Слушне правило таке: поле, яке ніхто не вимірював, лишається absent, бо «not measured» і «measured and came out zero» — різні речі. Ця функція тихо не погоджується.

Другий збій — duration. Clip-priced tariff обирає свій tier через maxDurationSeconds проти u.videoSeconds ?? 0, тож usage, який не записав duration, збігається з найкоротшим tier:

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

Сорок відсотків знижки за те, що ви не знаєте, якої довжини було відео. Обидва баги мають той самий корінь: default, обраний для зручності всередині функції, вся робота якої — бути точною.

Коли costs можна обчислити, порівнянню потрібна друга половина — оголошений representative workload, по одному на engine, сформульований публічно, щоб читач міг із ним не погодитися:

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

Кожен із цих рядків — аргумент. Text змішує чверть input і три чверті output, бо реальне використання схиляється до output; fifty-fifty blend ранжує моделі інакше. Image workload припускає 1,500 output tokens, між 1,056 OpenAI для medium square і 1,584 для medium portrait. Video припускає п’ять секунд у 1080p, і ми щойно бачили, як два постачальники міняються місцями на 1.2 секунди. Compute entry припускає шістдесят GPU-seconds, бо припустити більше нічого.

Ось метод, і це єдиний чесний метод: ви не можете порівнювати ціни в різних одиницях; ви можете порівнювати лише вартість workload, який ви записали. Будь-яка таблиця, що ранжує multimodal models без надрукованого workload, ранжує власні припущення.

Тепер ви можете оцінити все, що модель може створити, у будь-якій одиниці, у якій це продається, і вголос сказати, який workload припускає ваше порівняння. Це закриває інвойс, який відкрив Розділ 16, і закриває Частину III: усе від Розділу 14 до цього місця було про один call — як його зробити, що в нього покласти, як його sample, що він повертає, скільки коштує.

Розділ 22 змінює одиницю аналізу, і ця зміна дорога. agent — це не один call; це loop, який сам вирішує, скільки calls зробити, а арифметика останніх двох розділів перетворює це з architecture diagram на бюджет. Він починається з того, що ставить тій самій моделі те саме питання двічі, вдруге додаючи до каталогу один tool, і вимірює, що зробив цей один tool: один call став двома, тридцять дев’ять input tokens стали 420.

Чи робить це його agent, залежить від того, яке з двох опублікованих визначень ви відкриєте, і вони не погоджуються. Одне з них не погоджується саме із собою.

Кожну ціну, формулу й conversion rate у цьому розділі було прочитано зі сторінки самого постачальника 7 вересня 2026 року і процитовано з цією датою, бо всі вони зміняться. Token counts, costs і comparisons були обчислені на цих даних кодом, надрукованим вище, на одній машині, без жодного платного API call — і це також чесна причина, чому в цьому розділі немає жодної latency claim.

Image-token functions, cost tables, voice-call breakdown і empty-usage results були створені TypeScript, надрукованим у цьому розділі, запущеним на Node 22. Dialogue для voice comparison має 149 слів і був tokenized with tiktoken under the o200k_base encoding at 188 tokens; його duration випливає з оголошеної швидкості 150 слів за хвилину, яка є parameter of the comparison, а не measurement. Кожна provider figure має footnote, що називає сторінку, з якої її взято.