vitna.ai/docs/concepts/dimension Machine view
Raw .md llms.txt
> Source: https://vitna.ai/docs/concepts/dimension
> Raw Markdown: https://vitna.ai/docs/concepts/dimension.md
> Corpus index: https://vitna.ai/llms.txt

# Dimension

What a price is charged by. A [sku](sku.md) does not have "a price"; it has a
price per dimension, and most skus carry several.

Dimensions are registry rows in `witness.price_dimension`, each belonging to one
[component class](component-class.md).

## The registered dimensions

**Language models** (`model`):

| id | Label | Unit |
|---|---|---|
| `input_per_mtok` | Input price | USD per 1M tokens |
| `cached_input_per_mtok` | Cached input price | USD per 1M tokens |
| `cache_write_5m_per_mtok` | Cache write price, 5 minute retention | USD per 1M tokens |
| `cache_write_1h_per_mtok` | Cache write price, 1 hour retention | USD per 1M tokens |
| `output_per_mtok` | Output price | USD per 1M tokens |
| `batch_input_per_mtok` | Batch input price | USD per 1M tokens |
| `batch_output_per_mtok` | Batch output price | USD per 1M tokens |
| `priority_input_per_mtok` | Priority input price | USD per 1M tokens |
| `priority_output_per_mtok` | Priority output price | USD per 1M tokens |
| `flex_input_per_mtok` | Flex input price | USD per 1M tokens |
| `flex_output_per_mtok` | Flex output price | USD per 1M tokens |
| `output_per_image` | Output price, per image | USD per image |
| `batch_output_per_image` | Batch output price, per image | USD per image |

A model that emits images is billed by the image rather than by the token, so
the class carries two units rather than one. That is why the unit travels on the
figure and is not a property of the class.

**Agent tools** (`tooling`):

| id | Label | Unit |
|---|---|---|
| `tool_call_per_1k` | Per 1,000 calls | USD per 1,000 calls |
| `page_fetch_per_1k` | Per 1,000 pages | USD per 1,000 pages |
| `container_hour` | Container hour | USD per container-hour |
| `session_hour` | Session hour | USD per session-hour |
| `storage_per_gb_day` | Storage | USD per GB-day |

A fetched page is its own meter rather than a kind of call. One call can return
one page or several, and three of the four sellers on `page_fetch_per_1k` price
the page rather than the call. Putting both on one scale would invite a reader
to divide one by the other.

`session_hour` is a hosted session billed for as long as it runs, and neither
seller on it uses that name: one sells a managed agent session and the other
sells a browser hour. The id names the meter, as `input_per_mtok` does; sharing
one is not a claim that two products are the same, which is what a
[sku](sku.md)'s product slug says and these two do not share.

**Embedding and rerank** (`retrieval`), both USD per 1M tokens:

| id | Label |
|---|---|
| `embed_per_mtok` | Embedding price |
| `rerank_per_mtok` | Rerank price |

**Document extraction** (`extraction`), both USD per page:

| id | Label |
|---|---|
| `page_ocr` | Text from a page |
| `page_layout` | Structure from a page |

A page is not one thing across these providers. `page_ocr` is a page read for
its characters; `page_layout` is a page read for its tables, form fields and
layout blocks, and what that includes differs by provider. So every extraction
sku carries a `page` attribute saying which kind of page its figure is for, and
the boards print it under the rate. Two per-page figures compared without it
are two different products under one heading.

**Speech recognition and synthesis** (`speech`):

| id | Label | Unit |
|---|---|---|
| `audio_minute_batch` | Pre-recorded transcription | USD per audio-minute |
| `audio_minute_streaming` | Streaming transcription | USD per audio-minute |
| `tts_per_mchar` | Synthesis price | USD per 1M characters |

Transcription is two meters because every seller on the board sells it twice,
once for audio that has already been recorded and once for audio arriving live,
at two different prices. The two share a unit and are still two meters, which is
the same distinction `embed_per_mtok` and `rerank_per_mtok` carry: a unit is
what a figure is measured in and a meter is what is being sold.

That is also the admissibility test for this class, and it is stricter than it
sounds. A seller quoting one recognition rate covering both is quoting neither
of these meters, so the record declines it rather than filing the figure under
whichever of the two looks closest.

The audio-minute is the audio's own minute, not the wall clock. A pre-recorded
service that returns in ten seconds still bills the minute it read.

**GPU compute** (`compute`):

| id | Label | Unit |
|---|---|---|
| `gpu_hour_on_demand` | On-demand list price | USD per GPU-hour |

**Machine translation** (`translation`), both USD per 1M characters:

| id | Label |
|---|---|
| `translate_input_per_mchar` | Input price |
| `translate_output_per_mchar` | Output price |

Only the pay-as-you-go tier is registered. Every seller on that board also
prices a volume commitment, and a price for a promise about next year is not a
price a reader can take today.

The two meters are never summed. Three of the five products bill the characters
you send and carry no output figure at all; the other two are large language
models billing both ends. Google states on its own page that its ten dollar
each way product is cost equivalent with its twenty dollar one way product,
which holds at a one to one character ratio and at no other, so the board
prints the ends a buyer will actually send rather than an equivalence resting
on an assumption nobody made.
**Image generation** (`image`):

| id | Label | Unit |
|---|---|---|
| `image_per_image` | Per image | USD per image |
| `batch_image_per_image` | Batch price, per image | USD per image |
| `image_per_megapixel` | Per megapixel | USD per megapixel |

Two units again, and for a sharper reason than the model class has. Some sellers
charge one price for an image whatever size it is; others charge by the area of
what comes back. At a one-megapixel output the two can print the same number and
still be different products, because at two megapixels one of them has doubled.
So `image_per_megapixel` is a meter of its own rather than the same meter
converted, and no spread is ever drawn across the two.

`image_per_image` is not `output_per_image`. The latter is the model class's
meter for a language model whose output happens to be a picture, priced beside
its token rates on a token page; the former is an image product sold on its own.
A figure lives under one of them and never under both.

**Video generation** (`video`):

| id | Label | Unit |
|---|---|---|
| `video_per_second` | Per second | USD per second |

One meter, because one seller is read so far and it prices one way. What the
figure buys is on the sku rather than in the unit, and two things are on it
that move a price further than anything else in this class: the resolution,
where one model spans $0.05 to $0.60 a second, and whether audio is included,
because a rate for video with audio is not a rate for video without it.

The same page states a per-second equivalence for token-billed video and calls
it approximate. It is not read. An equivalence the seller itself hedges is not
a list price for this unit, and the rule that refuses a from-priced GPU refuses
this for the same reason.

**Music generation** (`music`):
| id | Label | Unit |
|---|---|---|
| `music_per_track` | Per track | USD per track |
One meter, for the same reason as video: one seller is read so far and it
prices one way. The page bills per request and a request returns one track, so
the two are the same thing counted from either end.

The length is on the sku rather than in the unit, and nothing divides by it.
The same seller charges $0.04 for a thirty second clip and $0.08 for a full
song, and the record carries those as two products rather than one rate at two
durations. Turning the clip into a price per second would invent a unit the
page does not sell: it sells a clip, not thirty seconds. The seller writes "per
song" against the clip row too, which is its wording rather than a mistake this
record corrects.

## A row carries only the dimensions its source publishes

If a provider's page does not quote a batch rate, that sku has no
`batch_input_per_mtok`, and the cell is absent from the tape rather than
present and zero. Absence is a fact about the market and gets reported as one.

## Sanity bounds are data, not parser code

Each dimension carries `sanityMinUsd` and `sanityMaxUsd`. A parsed figure
outside them is rejected as a probable misread rather than entering the record.

These live on the registry row rather than inside the adapter so that widening
one is a data change with a reason attached, not a code change buried in a
parser. Two of them have already been widened for exactly that reason: the
model input ceiling was $100 until OpenAI listed o1-pro at $150, which made the
bound a limit on Vitna's coverage rather than on what a parser could plausibly
have got wrong.

## Why every floor is above zero

The floor is not a claim that nothing is free. It is there because zero is what
a broken read returns.

A label that matched a navigation menu, a window that stopped before the
figures, a cell index that ran past the end of a row: each produces a nothing
that arithmetic turns into a nought, and each would otherwise put a free model
on a public board with no error raised anywhere.

A page that genuinely publishes $0.00 is a different thing and a real fact about
a market. The two are told apart by evidence rather than by declaration: a
figure carries the substring the document actually printed, so a zero has to be
shown to have been read rather than asserted to have been.

## An add-on is its own meter or it is absent

Every speech seller on the board prices diarisation, redaction, keyterm
prompting and the rest as separate per-minute rates beside the transcription
rate. None of them is registered and none of them is folded into the figure
above it, which is what makes the headline rate readable as a headline rate.

The rule generalises past speech: an add-on gets a dimension of its own when the
record decides to carry it, and until then the record carries the base rate and
says so. Folding one in would produce a number no document prints.

## A cache read and a cache write are two meters, and a write is two more

`cached_input_per_mtok` is the cached **read** rate: what a request pays for
tokens it found already in the cache. Filling the cache is a separate charge,
priced above uncached input, and it is the two `cache_write_*` meters.

Those two are one meter split by how long the seller promises to keep what was
written. The same tokens go in either way; a five minute window and an hour are
two prices for two promises, printed side by side on the same row of the same
page. That is the definition `batch_*`, `flex_*` and `priority_*` already use,
so a retention window joins the rule about service tiers below rather than
starting a new one.

**Why two dimensions rather than one carrying the window as an attribute.**
Three things decide it and none is taste.

A sku's `attrs` is a property of the sku, and one model carries both rates at
once. Putting the window there means one sku per window, which is the shape
[the context band](#a-context-band-is-not-a-dimension) refused for the same
reason: it doubles every count the boards print and makes a succession field
describe a lineage that is really one product.

A [spread](../api/v1/prices/spreads.md) groups by dimension. One dimension would
put a five minute write and an hour's write in one group and print the gap
between them as a dispersion. It is not one. It is the distance between two
products, and the record's own machinery would have manufactured exactly the
misreading this meter has to be safe from.

And the dimension id is what a figure carries everywhere it goes, into the
tape, into a bill line, into a citation. With the window in the id there is no
reading of $6.25 that could be the hour's rate.

The two names are names, not one name with a number in it. A seller pricing a
thirty minute window gets a third dimension rather than a third value of a
field, which is not hypothetical: Novita's pricing payload already carries
fields for a five minute and a thirty minute write, both empty of figures on
2026-09-10.

**One seller is on these meters. Four more publish a write rate and none of
them is filed**, for reasons worth keeping apart because only one of them is
about the market. Read 2026-09-10.

- **Anthropic** prints both windows in its own pricing table, and is read.
- **OpenAI** prints a cache-writes column in each of its four tier tables and
  names no retention window anywhere on the page, so there is no registered
  meter its figure belongs to. The temptation is the part worth recording:
  every row prints its write at exactly 1.25x its own input rate, and 1.25x is
  the five minute multiplier at every seller who publishes both windows. An
  inference that clean is exactly the kind this record does not make.
- **DeepInfra and Novita** carry theirs inside a script payload the HTML
  readers strip before any adapter sees it. A different parse strategy, not a
  new field.
- **Azure** lists cache-write meters in the Retail Prices API that the
  registered query does not ask for, and its meter names say nothing about a
  window either, so it is held by both of the reasons above at once.

Only OpenAI's is a document that has been read and does not say enough. The
other three are documents nobody has asked the right question of yet.

Novita has since been asked. Its pricing page now prints a write column at five
minutes and at an hour, and the adapter has read both since 2026-11-02, so two
sellers are on these meters and the second is the first in a peer set.

**Google is absent from these meters and is not one of those cases.** It prices
cache **storage**, per million tokens per hour, which is rent for holding a
cache rather than a charge for filling one, and a third unit as well as a third
meter. An hour appears in that figure and in `cache_write_1h_per_mtok`, and the
two have nothing to do with each other.

`rerank_per_mtok` is still the only rerank meter. Some providers sell reranking
per search instead. That is not a point on the same scale, so it gets its own
dimension when a source publishes one, rather than being converted into this
one at an assumed document count.

## What a cache write can and cannot be set against

Asked because a meter that draws no board should say so rather than have
somebody find out by drawing one.

**Against a cache read: never.** A write and a read are different events at
different prices and the dispersion between them is not a fact about a market.
Nothing has to remember this. The spread groups by dimension and they are two.

**Against a write at another window: never.** Five minutes of retention and an
hour of it are two products, and the gap between them is the price of the
longer promise rather than a disagreement between sellers. This is guarded the
same way and only because the window is in the id.

**Against another seller's write at the same window: yes, with a note.** Both
meters are in the model board's own unit, so nothing bars them from a spread. A
dispersion on this board is several sellers of one product, grouped by the
product slug an open-weight row carries. Novita's write columns reached three
such peer sets in the snapshot of 2026-11-03 (Kimi K3, Qwen3.8 Max and Qwen3.8
Flash), and Novita is the only seller filing a write in each, so no write spread
is drawn yet. The reason is coverage rather than category.

The note is the one thing that had to be settled before the first such spread,
and it was settled when those peer sets arrived. Sellers cache in blocks, and
the block size is theirs to choose: DeepInfra's own page states a per-model
granularity running from 1,024 to 8,192 tokens with the remainder billed as
standard input. Two sellers quoting the same rate per million tokens at the same
retention window are therefore not necessarily selling the same thing, in the
way two per-page extraction figures are not. So every answer that sets one
seller's write against another's carries it as `blockNote`: the
[spread](../api/v1/prices/spreads.md#cache-writes) and the peer range a
[quote check](../api/v1/prices/quote-check.md) reads. No other meter does.

## A character is not a token

`translate_input_per_mchar` is per million characters. `input_per_mtok` is per
million tokens. The record does not convert between them and will not.

A conversion needs a characters-per-token ratio, and no such constant exists.
It is a property of a tokenizer and a language at once: near four characters to
the token for English, far denser for Chinese, Japanese, Korean and Thai.
Translation crosses languages by definition, so a single ratio would be wrong
by a multiple in exactly the work this class is about.

The meters are not counting the same events either. Google states that markup,
whitespace and untranslated characters are all charged, and that a request with
no content is charged one character. No token meter behaves that way.

So both prices stand in their own unit, side by side, and the ratio between
them is a measurement somebody takes on their own corpus. That is the same rule
the record already applies to quality: measured on your own documents, or not
claimed. A dedicated translator priced per million characters standing beside a
general model priced per million tokens is a comparison worth having, and it is
worth having in two units rather than in one invented one.

## A service tier is a dimension

Providers sell the same model at more than one speed. A batch tier runs the work
whenever there is room and costs less; a priority tier runs it sooner and costs
more; a flex tier sits between standard and batch. Each is a separate rate the
provider publishes on the same page, and each is registered as its own meter.

That is what `batch_input_per_mtok` has always been, so the six tier meters are
one rule rather than three special cases: `batch_*`, `flex_*` and `priority_*`
are the same model billed under a different service promise, and a buyer chooses
between them per request.

`priority_*` is named for the meter rather than for what any one seller calls it
this year. OpenAI's page prints "Fast pricing data" and states in its own
footnote that the tier was called Priority processing until 30 July 2026 and
that `service_tier: "priority"` is still accepted; Anthropic prints "Fast mode
pricing" and takes `speed: "fast"`. An id tracking the marketing word would have
needed renaming once already, so the id is Vitna's and the
[locator](observation.md) quotes the page.

Sharing a dimension is not a claim that two sellers' tiers are one product. A
dimension is the meter; a peer set is the product, and these two sellers share
none, so no spread is drawn across them. `container_hour` already carries that
distinction for OpenAI's sized containers against Anthropic's unsized one.

## A context band is not a dimension

Some providers price one model differently by how much context a request
carries. That is a property of the price rather than a new meter, so it travels
on the figure as a band rather than as a dimension of its own.

The other option was to register a second long-context dimension beside
`input_per_mtok`, and it was refused because it would have meant every consumer
learning a second name for the same meter, and every unbanded sku carrying a
column it never fills. See [the tape](../api/v1/prices/tape.md#context-bands).

## Money

Amounts are `numeric(14,6)` USD, in the unit the dimension declares. Six
decimal places because a per-token price is quoted per million tokens and
dividing back to a single token has to stay exact.
Human Machine Shift+M