Multimodal Pricing: за что на самом деле платят в изображениях, аудио и видео

transformer принимает последовательность векторов. Ему всё равно, откуда они взялись. В Главе 8 в него подавались embeddings, найденные по token id; в архитектуре ничто не требует именно такого поиска.

Итак: разрежьте картинку на фиксированные квадраты, разверните каждый квадрат в список чисел и пропустите каждый список через один обученный линейный слой, чтобы получить вектор ширины модели. Патч цветных пикселей 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 model с тех пор выглядит примерно одинаково.⁴

Последствие для вашего счёта немедленное и не гламурное: патчи — это позиции в последовательности, значит, они input tokens, значит, вы платите за них по входному тарифу. Сколько их — вопрос арифметики, и каждый провайдер делает её по-своему.

Каждое правило ниже реализовано по собственной документации провайдера и сверено с разобранными примерами в той же документации.

OpenAI покрывает изображение патчами 32 × 32 и умножает их количество на коэффициент конкретной модели. Если число патчей превышает бюджет для этой модели и уровня детализации, изображение уменьшается, пока не поместится:

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

Google вообще не считает пиксели. Изображение, у которого обе стороны не больше 384 пикселей, стоит фиксированные 258 tokens. Всё большее режется на тайлы по 258 tokens каждый, а сетка тайлов получается из 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 даёт оба tier для всех шести размеров. Теперь эти правила можно запускать на любой вашей фотографии, и в этом суть: это единственные три функции в этой главе, которые нельзя получить со страницы цен.

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

Прочитайте последний столбец сверху вниз. Как только картинка превышает 384 пикселя, число больше никогда не меняется — и это не совпадение и не потолок. Подставьте crop unit обратно в формулу тайлов для изображения, которое как минимум не уже, чем выше:

Размер сокращается. Google's image tokens зависят от соотношения сторон и больше ни от чего. Фотография 4:3 — это четыре тайла, будь она миниатюрой или постером. Один этот алгебраический факт полностью объясняет ноль в таблице экономии выше, и ни одна страница цен нигде его не формулирует.

Два других столбца вместо этого упираются в потолок — на разных высотах и по разным причинам: Anthropic в объявленный token ceiling, 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 патча, а high — тот же pixel limit с бюджетом 2,500 патчей, «so it can use more tokens than high».⁷ Слово low называет настройку качества, а не цену: в двух из пяти документированных семейств моделей оно вообще не даёт экономии, а в одном из этих двух стоит дороже.

Всё до сих пор было о модели, которая читает изображение. Создание изображения работает на механизме, в котором вообще нет tokens, и именно поэтому оно продаётся по картинкам, а не по словам.

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

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

Так что цена за изображение — это цена за token со встроенным count. Это нормально, но кое-что скрывает. Возьмите таблицу текущего поколения и разделите обратно:

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

Большее изображение оказывается дешевле при любом качестве. Canvas 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 секунд аудио — и получите три системы единиц от двух поставщиков:

Один и тот же поставщик продаёт обе единицы: OpenAI tts-1 оценивается за миллион символов, а gpt-4o-mini-tts — за миллион tokens, $0.60 на входе и $12.00 на выходе.¹³ Поэтому «самый дешёвый 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, и именно он делает следующий раздел дорогим.

Теперь число, которое решает, является ли голос функцией или продуктом.

Звонок: support-разговор на десять реплик, 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.

Теперь сравнение, которое определяет продукт: все четыре варианта нормированы к минуте:

Тридцать восемь раз. Не тридцать восемь процентов. Идентичный обмен, проведённый звуком вместо текста, почти на два порядка дороже, и ни одна часть этого разрыва не является маржой, которую кто-то решил взять, — это коэффициент преобразования. Одна секунда assistant audio — это двадцать tokens. Та же секунда несёт 2,5 слова при заявленной скорости, а измеренная транскрипция идёт по 1,26 token на слово, то есть как текст это 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, поэтому всё, что вставлено в начало разговора в середине звонка, уничтожает его, а естественное место для «звонящий теперь проверен» — именно там.

И ничто, что вы делаете в клиенте, не отменяет счёт за звук. Пользователь говорит поверх assistant, ваш код останавливает playback, динамик замолкает. Всё, что уже было сгенерировано, уже списано, потому что billing накапливается при создании response; и по правилу Главы 16 всё, что остаётся в разговоре, заново отправляется как input audio на каждом следующем turn. Глава 14 говорила это об остановке text stream. В голосе это стоит в тридцать раз дороже.

Видео одни поставщики продают посекундно, другие — по клипам, с уровнями для разрешения и иногда длительности. Эти две формы отличаются не только удобством; они пересекаются.

Поставщик с оплатой за клип дороже посекундного ниже 1,2 секунды и в 16,7 раза дешевле на двадцати секундах. Никакой порядок этих двух моделей не переживает изменения длины клипа, поэтому «какая video model дешевле» — это вопрос не о моделях.

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

Итак: tokens, image tokens, символы, минуты, video seconds, целые клипы, 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 — форму, которую вы получаете, когда измерение не удалось, — и смотрите:

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

Ничего не произошло шесть раз, и один раз это стоило три доллара, а пять раз — ничего. Это не разница округления; это решение о том, что означает отсутствующее число, принятое отдельно для каждой unit и нигде не записанное. Здравое правило таково: поле, которое никто не измерял, остаётся отсутствующим, потому что «не измерено» и «измерено и получилось ноль» — разные вещи. Эта функция тихо не согласна.

Второй сбой — длительность. Тариф за клип выбирает свой tier через maxDurationSeconds против u.videoSeconds ?? 0, поэтому usage, который никогда не записал duration, попадает в самый короткий tier:

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

Скидка сорок процентов за незнание длины видео. У обоих багов один корень: default, выбранный ради удобства внутри функции, вся работа которой — быть точной.

Когда затраты можно вычислить, сравнению нужна вторая половина — объявленный 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 },
};

Каждая из этих строк — аргумент. Текст смешивает четверть input и три четверти output, потому что реальное использование смещено к output; смесь пятьдесят на пятьдесят ранжирует модели иначе. Image workload предполагает 1,500 output tokens — между 1,056 OpenAI для medium square и 1,584 для medium portrait. Video предполагает пять секунд при 1080p, а мы только что видели, как два поставщика меняются местами на 1,2 секунды. Compute-запись предполагает sixty GPU-seconds, потому что предполагать больше нечего.

В этом и метод, и это единственный честный доступный метод: нельзя сравнивать цены в разных единицах; можно сравнивать только стоимость workload, который вы записали. Любая таблица, ранжирующая multimodal models без напечатанного workload, ранжирует собственные допущения.

Теперь вы можете оценить всё, что модель может произвести, в какой бы unit это ни продавалось, и вслух сказать, какой workload предполагало ваше сравнение. Это закрывает инвойс, открытый Главой 16, и закрывает Часть III: всё от Главы 14 до этого места было об одном вызове — как его сделать, что в него положить, как его sample, что он возвращает, сколько стоит.

Глава 22 меняет единицу анализа, и это изменение дорогое. agent — это не один вызов; это loop, который сам решает, сколько вызовов сделать, а арифметика последних двух глав превращает это из архитектурной диаграммы в бюджет. Она начинается с того, что задаёт один и тот же вопрос одной и той же модели дважды, добавляя во второй раз один tool в каталог, и измеряет, что сделал этот один tool: один вызов стал двумя, тридцать девять input tokens стали 420.

Делает ли это его agent, зависит от того, какое из двух опубликованных определений вы откроете, и они не согласны. Одно из них не согласно само с собой.

Каждая цена, формула и ставка преобразования в этой главе были взяты со страницы самого поставщика 7 сентября 2026 года и цитируются с этой датой, потому что все они изменятся. Token counts, costs и comparisons были вычислены на этих данных кодом, напечатанным выше, на одной машине, без платного API-вызова — что также является честной причиной, почему в этой главе нет ни одного утверждения о latency.

Image-token functions, cost tables, voice-call breakdown и empty-usage results были произведены TypeScript, напечатанным в этой главе, запущенным на Node 22. Диалог, использованный для voice comparison, содержит 149 слов и был tokenized с tiktoken под encoding o200k_base в 188 tokens; его duration следует из объявленной скорости 150 слов в минуту, которая является параметром сравнения, а не измерением. Каждая provider figure сопровождается footnote, называющей страницу, с которой она взята.