Multimodale Preise: Was Bilder, Audio und Video wirklich kosten

Ein transformer nimmt eine Sequenz von Vektoren. Ihm ist egal, woher sie kommen. Kapitel 8 hat ihn mit embeddings gefüttert, die über eine token-ID nachgeschlagen wurden; nichts an der Architektur verlangt dieses Nachschlagen.

Also: Schneide das Bild in feste Quadrate, flache jedes Quadrat zu einer Zahlenliste ab und schiebe jede Liste durch eine gelernte lineare Schicht, um einen Vektor in der Breite des Modells zu erhalten. Ein 32 × 32-Patch aus Farbpixeln sind $32 \times 32 \times 3 = 3072$ Zahlen; die Projektion $E \in \mathbb{R}^{d \times 3072}$ verwandelt ihn in einen $d$-dimensionalen Vektor, exakt die Form, in der ein Text-token ankommt. Das ist schon alles, und es ist das Paper, dessen Titel es sagt: Ein Bild ist 16 × 16 Wörter wert.¹ Füge eine Positionscodierung hinzu, damit das Modell weiß, welches Quadrat wo lag, verwebe die Ergebnisse mit den Text-embeddings, und die Sequenz, die das Modell liest, ist teils Bild und teils Satz.

Drei Papers machten daraus ein Produkt. CLIP trainierte einen Bild-Encoder und einen Text-Encoder darauf, sich bei vierhundert Millionen gescrapten Paaren einig zu sein — der Punkt, an dem die Idee, dass Pixel und Wörter sich einen Raum teilen können, aufhörte, eine Hypothese zu sein.² Flamingo schraubte einen eingefrorenen Vision-Encoder mit ein paar trainierten Brückenschichten an ein eingefrorenes Sprachmodell.³ LLaVA zeigte, dass die Brücke eine einzelne lineare Projektion sein konnte und instruction-following mit generierten Daten gelernt werden konnte — weshalb seitdem jedes offene Vision-Language-Modell ungefähr gleich aussieht.⁴

Die Folge für deine Rechnung ist unmittelbar und unglamourös: Die Patches sind Positionen in der Sequenz, also sind sie input tokens, also zahlst du sie zum input-Tarif. Wie viele es sind, ist Arithmetik, und jeder Anbieter macht sie anders.

Jede Regel unten ist aus der eigenen Dokumentation des Anbieters implementiert und gegen die durchgerechneten Beispiele in derselben Dokumentation geprüft.

OpenAI deckt das Bild mit 32 × 32-Patches ab und multipliziert die Anzahl mit einem modellabhängigen Faktor. Wenn die Patch-Anzahl das Budget für dieses Modell und diese Detailstufe übersteigt, wird das Bild herunterskaliert, bis es passt:

Anthropic deckt es mit 28 × 28-Patches ab, ein visueller token pro Patch, und begrenzt sowohl die lange Kante als auch die token-Zahl — 1.568 Pixel und 1.568 tokens bei Standard-Tier-Modellen, 2.576 und 4.784 im High-Resolution-Tier. Übergroße Bilder werden auf die größte Größe skaliert, die in beide Grenzen passt.⁵

Google zählt Pixel überhaupt nicht. Ein Bild, dessen beide Seiten höchstens 384 Pixel haben, kostet pauschal 258 tokens. Alles Größere wird in Kacheln zu je 258 tokens geschnitten, und das Kachelraster entsteht aus einer Crop-Einheit von $\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;      
}

Lass jede Regel gegen die Zahlen laufen, die ihr eigener Anbieter abdruckt:

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

Neun Übereinstimmungen werden ausgegeben; der volle Lauf prüft fünfzehn, weil Anthropics Tabelle beide Tiers für alle sechs Größen liefert. Die Regeln gehören dir jetzt, für jedes Foto, das du hast — und das ist der Punkt: Das sind die einzigen drei Funktionen in diesem Kapitel, die du nicht von einer Preisseite bekommst.

Schicke dasselbe 4:3-Foto in sechs Größen durch alle drei:

Lies die letzte Spalte nach unten. Sobald das Bild über 384 Pixel kommt, ändert sich die Zahl nie wieder, und das ist kein Zufall und kein Cap. Setze die Crop-Einheit zurück in die Kachelformel ein, für ein Bild, das mindestens so breit wie hoch ist:

Die Größe kürzt sich heraus. Googles Bild-token hängen vom Seitenverhältnis ab und von nichts sonst. Ein 4:3-Foto besteht aus vier Kacheln, egal ob es ein Thumbnail oder ein Poster ist. Diese eine algebraische Tatsache ist die gesamte Erklärung für die Null in der Spartabelle oben, und keine Preisseite irgendwo sagt sie.

Die anderen beiden Spalten cappen stattdessen, in unterschiedlichen Höhen und aus unterschiedlichen Gründen — Anthropic bei einer deklarierten token-Obergrenze, OpenAI bei einem Patch-Budget nach einer Pixelgrenze — weshalb sich die drei Kurven bei unterschiedlichen Größen schneiden.

Jetzt mach es kaputt. Der offensichtliche Weg, weniger für ein Vision-Modell auszugeben, ist weniger Detail anzufordern, also sende detail: "low":

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

Weniger Detail anzufordern kostete 25 % mehr. Das ist kein Bug, und OpenAI sagt es in einer Zeile der Größen-Tabelle: In dieser Modellfamilie nutzt low ein 2048-Pixel-Limit mit einem 6.144-Patch-Budget, während high dasselbe Pixel-Limit mit einem 2.500-Patch-Budget nutzt, „so it can use more tokens than high“.⁷ Das Wort low bezeichnet eine Fidelity-Einstellung, keinen Preis: Bei zwei der fünf dokumentierten Modellfamilien spart es gar nichts, und bei einer dieser beiden kostet es mehr.

Alles bisher war ein Modell, das ein Bild liest. Eines zu machen läuft auf einem Mechanismus, in dem es gar keine tokens gibt, und genau deshalb wird es pro Bild verkauft statt pro Wort.

Anbieter veröffentlichen Bildgenerierung als Preis pro Bild. Das ist er nicht. GPT-Image-Modelle geben spezialisierte Bild-token aus, deren Anzahl von angeforderter Größe und Qualität abhängt; multipliziere die veröffentlichten Zahlen mit GPT Image 1s veröffentlichtem Bild-output-Tarif von $40 pro Million und vergleiche mit den Pro-Bild-Preisen auf derselben Seite:

Neun abgeleitete Werte gegen neun veröffentlichte, jedes Paar innerhalb von $0.002.¹¹ Google ist noch expliziter und macht die Umrechnung auf der Preisseite selbst: Bild-output zu $60 pro Million tokens, „output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image“.¹²

Ein Preis pro Bild ist also ein Preis pro token mit eingeklappter Anzahl. Das ist in Ordnung, und es versteckt etwas. Nimm die Tabelle der aktuellen Generation und teile rückwärts:

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

Das größere Bild ist bei jeder Qualität das günstigere. Eine 1024 × 1536-Leinwand hat 50 % mehr Pixel als eine 1024 × 1024-Leinwand und kostet bei medium 23 % weniger tokens. OpenAI markiert es in einem Satz, den du überspringen würdest — „a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting“ — und in der vorherigen Modellgeneration lief es andersherum, Portrait kostete 50 % mehr als Quadrat.¹¹ Jeder Default von 1024x1024, der vor dieser Änderung geschrieben wurde, ist jetzt die teure Option.

Bitte drei Produkte, dieselben 519 Zeichen zu sprechen — etwa 38 Sekunden Audio — und du bekommst drei Einheitensysteme von zwei Anbietern:

Derselbe Anbieter verkauft beide Einheiten: OpenAIs tts-1 wird pro Million Zeichen bepreist, während gpt-4o-mini-tts pro Million tokens bepreist wird, $0.60 rein und $12.00 raus.¹³ „Günstigstes text-to-speech“ ist also keine Frage mit Antwort, bis du sagst, was gesprochen wird.

Und die zwei Einheiten sind für Gegenteiliges blind. Ein Pro-Zeichen-Preis sieht Dauer nicht: Wähle eine langsame, bedächtige Stimme oder füge Pausen hinzu, und die Rechnung bewegt sich nicht, während das Audio länger wird. Ein Pro-Sekunde-Preis sieht Inhalt nicht: Dreißig Sekunden kosten gleich viel, ob es ein dichter technischer Absatz ist oder jemand bis zehn zählt. Ändere die Stimme, und exakt einer deiner beiden Anbieter bepreist neu.

Transkription läuft andersherum und ist die einfachste Zeile auf der ganzen Rechnung — pro Audiominute, pauschal:

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)

Beachte die letzte Zeile gegen die dritte: Es live zu machen, während die Wörter eintreffen, kostet 5,7-mal so viel wie es an einer fertigen Datei zu machen. Diese Lücke ist der Preis dafür, nicht batchen zu können, und sie macht den nächsten Abschnitt teuer.

Jetzt die Zahl, die entscheidet, ob Voice ein Feature oder ein Produkt ist.

Der Anruf: ein Supportgespräch mit zehn Turns, 149 Wörter, was bei deklarierten 150 Wörtern pro Minute 59,6 Sekunden Sprache sind — 21,2 vom Anrufer gesprochen, 38,4 zurückgesprochen. Die token-Umrechnungen sind die der Anbieter selbst. 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 pro Sekunde in beide Richtungen, was seine Preisseite bestätigt, indem sie $12.00 pro Million und $0.018 pro Minute in derselben Zeile veröffentlicht.¹²

Das Gespräch akkumuliert genau so, wie Kapitel 16 gesagt hat, weil es derselbe Mechanismus ist: „the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive“.¹⁴ Nur wird die History jetzt in Audio-token gemessen.

Jetzt der Vergleich, der das Produkt entscheidet, alle vier auf eine Minute normalisiert:

Achtunddreißigfach. Nicht achtunddreißig Prozent. Derselbe Austausch, in Sound statt Text geführt, ist fast zwei Größenordnungen teurer, und keine dieser Lücken ist eine Marge, die jemand verlangt — es ist die Umrechnungsrate. Eine Sekunde Assistant-Audio sind zwanzig tokens. Dieselbe Sekunde trägt bei der deklarierten Rate 2,5 Wörter, und das gemessene Transkript läuft mit 1,26 tokens pro Wort, also sind es als Text 3,15 tokens. Sound ist ein 6,3-mal sperrigeres Paket für dieselbe Bedeutung, und jeder seiner tokens wird mit dem 5,3-Fachen des Text-output-Tarifs und dem 16-Fachen des Text-input-Tarifs abgerechnet. Multipliziere ein Volumenverhältnis mit einem Preisverhältnis, und die Größenordnung ist schon da, bevor irgendeine Buchhaltung beginnt.

Zwei operative Folgen fallen direkt aus der Tabelle.

Audio-Caching ist keine Optimierung, es ist das Geschäftsmodell. Gecachter Audio-input kostet $0.40 pro Million gegenüber $32.00 frisch — ein Rabatt von 98,75 %, der den Anruf halbiert. Die Regel ist die aus Kapitel 16, unverändert: Der Cache matcht ein Präfix, also zerstört alles, was mitten im Call vorne in das Gespräch eingefügt wird, ihn, und der natürliche Ort für „der Anrufer ist jetzt verifiziert“ ist genau dort.

Und nichts, was du im Client tust, ent-rechnet einen Sound. Der User spricht dem Assistant ins Wort, dein Code stoppt die Wiedergabe, der Lautsprecher wird still. Was bereits generiert war, wurde bereits berechnet, weil Billing anfällt, wenn die Response erzeugt wird; und nach Kapitel 16s Regel wird alles, was im Gespräch bleibt, in jedem Turn danach erneut als Audio-input gesendet. Kapitel 14 hat diesen Punkt beim Abbrechen eines Text-Streams gemacht. In Voice kostet er dreißigmal mehr.

Video wird von manchen Anbietern pro Sekunde verkauft und von anderen pro Clip, mit Tiers für Auflösung und manchmal für Dauer. Diese zwei Formen unterscheiden sich nicht nur in Bequemlichkeit; sie kreuzen sich.

Der Pro-Clip-Anbieter ist unter 1,2 Sekunden teurer als der Pro-Sekunde-Anbieter und bei zwanzig Sekunden 16,7-mal günstiger. Keine Reihenfolge dieser zwei Modelle übersteht eine Änderung der Cliplänge, also ist „welches Videomodell ist am günstigsten“ keine Frage über Modelle.

Die letzte Zeile ist schlimmer, und sie ist der ehrliche Kern des Kapitels. mochi wird gegen echte GPU-Sekunden abgerechnet — die gemessene Prediction-Zeit des Jobs — zu $0.001400 pro Sekunde auf einer A100 und $0.001525 auf einer H100; das sind die Tarife der gemieteten Maschine und sonst nichts.¹⁵ Das ist ein vollkommen präziser Tarif und kein Preis, weil die Menge, mit der er multipliziert wird, unbekannt ist, bis du dich bereits verpflichtet hast, ihn zu zahlen. Die Zeile oben nimmt zwölf GPU-Sekunden pro Sekunde output an; vervierfache diese Annahme, und sie verlässt das günstigste Band, und erst beim Sechsfachen landet sie in der Tabellenmitte. Es ist der einzige Tarif auf dieser Seite, den du nicht in ein Angebot schreiben kannst.

Also: tokens, Bild-token, Zeichen, Minuten, Videosekunden, ganze Clips, GPU-Sekunden, Pauschaleinheiten. Acht Größen, und der einzige Weg, sie auf eine Achse zu bringen, ist, einen Workload zu deklarieren und ihn zu bepreisen.

Das ist die Erweiterung von Kapitel 16s computeCost — dieselbe Tier-Maschinerie, jetzt mit Kriterien, die nicht prompt-Länge sind:

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

Die zwei markierten Zeilen sind die Bruchstellen. Ein pro Einheit angegebener Tarif multipliziert u.images ?? 1; ein pro token angegebener Tarif multipliziert etwas, das standardmäßig null ist. Gib beiden eine leere Usage — die Form, die du bekommst, wenn eine Messung fehlgeschlagen ist — und schau zu:

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

Nichts ist passiert, sechsmal, und es kostete einmal drei Dollar und fünfmal nichts. Das ist kein Rundungsunterschied; es ist eine Entscheidung darüber, was eine fehlende Zahl bedeutet, separat für jede Einheit getroffen und nirgends niedergeschrieben. Die solide Regel lautet, dass ein Feld, das niemand gemessen hat, absent bleibt, weil „nicht gemessen“ und „gemessen und null herausgekommen“ verschiedene Dinge sind. Diese Funktion widerspricht leise.

Der zweite Fehler ist Dauer. Der Clip-bepreiste Tarif wählt sein Tier mit maxDurationSeconds gegen u.videoSeconds ?? 0, also matcht eine Usage, die nie eine Dauer aufgezeichnet hat, das kürzeste Tier:

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

Vierzig Prozent Rabatt dafür, nicht zu wissen, wie lang das Video war. Beide Bugs haben dieselbe Wurzel: ein Default, der aus Bequemlichkeit in einer Funktion gewählt wurde, deren ganze Aufgabe Exaktheit ist.

Wenn Kosten berechenbar sind, braucht der Vergleich die andere Hälfte — einen deklarierten repräsentativen Workload, einen pro Engine, öffentlich angegeben, damit ein Leser ihm widersprechen kann:

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

Jede dieser Zeilen ist ein Argument. Text mischt ein Viertel input und drei Viertel output, weil reale Nutzung zum output kippt; ein Fifty-fifty-Blend rankt die Modelle anders. Der Bild-Workload nimmt 1.500 output tokens an, zwischen OpenAIs 1.056 für ein medium-Quadrat und 1.584 für ein medium-Portrait. Video nimmt fünf Sekunden bei 1080p an, und wir haben gerade zwei Anbieter bei 1,2 Sekunden die Plätze tauschen sehen. Der Compute-Eintrag nimmt sechzig GPU-Sekunden an, weil es nichts anderes anzunehmen gibt.

Das ist die Methode, und es ist die einzige ehrliche: Du kannst Preise in unterschiedlichen Einheiten nicht vergleichen; du kannst nur die Kosten eines Workloads vergleichen, den du aufgeschrieben hast. Jede Tabelle, die multimodale Modelle rankt, ohne ihren Workload abzudrucken, rankt ihre eigenen Annahmen.

Du kannst jetzt alles bepreisen, was ein Modell erzeugen kann, in welcher Einheit es auch verkauft wird, und laut sagen, welchen Workload dein Vergleich angenommen hat. Das schließt die Rechnung, die Kapitel 16 geöffnet hat, und es schließt Teil III: Alles von Kapitel 14 bis hier ging um einen Call — wie man ihn macht, was man hineinlegt, wie man ihn sampelt, was er zurückgibt, was er kostet.

Kapitel 22 ändert die Analyseeinheit, und die Änderung ist teuer. Ein agent ist nicht ein Call; er ist eine Schleife, die selbst entscheidet, wie viele Calls sie macht, und die Arithmetik der letzten beiden Kapitel verwandelt das von einem Architekturdiagramm in ein Budget. Es beginnt damit, dieselbe Frage demselben Modell zweimal zu stellen, beim zweiten Mal mit einem Tool mehr im Katalog, und zu messen, was dieses eine Tool getan hat: ein Call wurde zu zwei, neununddreißig input tokens wurden zu 420.

Ob das daraus einen agent macht, hängt davon ab, welche von zwei veröffentlichten Definitionen du öffnest, und sie stimmen nicht überein. Eine davon stimmt nicht mit sich selbst überein.

Jeder Preis, jede Formel und jede Umrechnungsrate in diesem Kapitel wurde am 7. September 2026 von der eigenen Seite des Anbieters gelesen und mit diesem Datum zitiert, weil sich alles davon bewegen wird. Die token-Zahlen, Kosten und Vergleiche wurden auf diesen Daten durch den oben abgedruckten Code berechnet, auf einer Maschine, ohne bezahlten API-Call — was auch der ehrliche Grund ist, warum es in diesem Kapitel keine einzige Latenzbehauptung gibt.

Die Bild-token-Funktionen, die Kostentabellen, die Voice-Call-Aufschlüsselung und die Empty-Usage-Ergebnisse wurden durch das in diesem Kapitel abgedruckte TypeScript erzeugt, ausgeführt auf Node 22. Der Dialog für den Voice-Vergleich hat 149 Wörter und wurde mit tiktoken unter dem o200k_base-Encoding bei 188 tokens tokenisiert; seine Dauer folgt aus einer deklarierten Rate von 150 Wörtern pro Minute, die ein Parameter des Vergleichs ist und keine Messung. Jede Anbieterzahl trägt die Fußnote, die die Seite nennt, von der sie stammt.