> ## Documentation Index
> Fetch the complete documentation index at: https://docs.venice.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> The Venice API is OpenAI-compatible: use any OpenAI SDK with the base URL `https://api.venice.ai/api/v1` and a Venice API key, or pay per request from a USDC wallet through x402 with no account.
> Read model IDs from `GET /models` or `GET /models/traits` at runtime instead of hardcoding them from memory or from these pages. Models are added and retired often.
> Every model's price is in https://docs.venice.ai/pricing.md. Quote video and audio jobs with `POST /video/quote` or `POST /audio/quote` before you queue them.
> Search these docs from an MCP client at https://docs.venice.ai/mcp. The full agent guide is https://docs.venice.ai/agents.md.

# How the model catalog works

> How Venice builds the model catalog: model families and variants, normalized prices for every modality, privacy tiers, and the reference prompt suite.

The [model catalog](https://docs.venice.ai/models/overview.md) is generated from [`GET /models`](https://docs.venice.ai/api-reference/endpoint/models/list) every hour. This page explains how the numbers on it are derived, so you can reproduce them and know what they do and don't mean.

## Families and variants

Many model IDs are the same model offered in a different way. The catalog groups them into one family page:

| Variant type | Example | Why it's separate |
| - | - | - |
| Speed | `claude-opus-5-5` and `claude-opus-5-5-fast` | Faster serving at a higher price |
| Mode | `kling-v3-pro-text-to-video`, `-image-to-video`, `-motion-control` | Different inputs and prices |
| Task | `nano-banana-pro` and `nano-banana-pro-edit` | Generation and editing endpoints |

Every variant keeps its own model ID, price and privacy tier. Pass the variant's ID as `model`. Dated snapshots such as `deepseek-v4-flash-0731` stay separate families and appear under **Other versions**.

An E2EE build, such as `e2ee-glm-5-3-p` for `z-ai-glm-5-3`, has a page of its own rather than being a variant: calling it takes the E2EE handshake, and its limits and price differ. Its page is named for its model plus E2EE, at the model's URL plus `-e2ee`, and each of the two pages links to the other.

## Normalized prices

Each modality bills in its own unit. The catalog shows the native unit and one reference price, so models can be sorted and compared.

| Modality | Native unit | Reference price |
| - | - | - |
| Text | Per 1M input and output tokens | **Blended**: `(3 × input + output) / 4`, the 3:1 mix Artificial Analysis uses. The cached-input discount is `1 − cached ÷ input`. |
| Image | Per image, by resolution tier | Price per image at the selected tier (1K, 2K or 4K). Edits add a per-image surcharge for extra inputs. |
| Video | Per clip, by resolution, duration and audio | Price per second and per clip at the selected settings, from a full quote matrix (below). |
| Text to speech | Per 1M characters | Per minute of speech at 150 words (about 825 characters) per minute. |
| Speech to text | Per audio second | Per audio hour and per 1,000 minutes. |
| Music and sound effects | Per track, per second or per duration bucket | Per minute of audio where the model allows it; otherwise per track. |
| Embeddings | Per 1M input tokens | Unchanged. |

> [!NOTE]
>
> Reasoning models can spend many more output tokens than non-reasoning models on the same task, so the blended price understates their real cost. Cost per task, measured on benchmark runs, is planned; see [Benchmarks](#benchmarks).

### Video pricing

Video models don't publish prices in `GET /models`. At build time, Venice calls [`POST /video/quote`](https://docs.venice.ai/api-reference/endpoint/video/quote) for every resolution × duration × audio combination each model supports, at its first listed aspect ratio (aspect ratio does not change the price). The catalog stores the full matrix and derives:

* **Per second**: the median of `price ÷ seconds` across durations at a given resolution and audio setting. Prices are linear in duration for almost every model.
* **Draft clip**: 5 seconds, 720p, silent.
* **Production clip**: 10 seconds, 1080p, with audio.

When a model doesn't offer the requested setting, the catalog uses the closest one it supports and marks the price. Edit, motion-control and upscale modes bill by the length of your source video, so they show **By source** instead of a price. Always call `POST /video/quote` before queueing for an exact amount.

## Privacy tiers

| Tier | What it means |
| - | - |
| **E2EE** | Prompts are encrypted on your device and decrypted only inside an attested hardware enclave. See [TEE & E2EE models](https://docs.venice.ai/guides/features/tee-e2ee-models.md). |
| **TEE** | Inference runs in a hardware enclave with cryptographic attestation. |
| **Private** | Served on infrastructure Venice controls, with zero data retention. |
| **Anonymized** | Proxied to the upstream lab without your identity. The lab may retain prompts. |

A family lists every tier its variants offer. Filtering by a tier shows the variant in that tier, with its own price.

## Reference prompt suite

Image and video models are rendered on a fixed prompt suite, the same prompts for every model of a modality, at default settings. That's what keeps the explorer's gallery comparable from one model to the next.

| Modality | Prompts |
| - | - |
| Image | In-image text, photorealism, instruction following, illustration style |
| Image editing | One source photo, edited three ways: a local change, a restyle and added text |
| Upscaling | A 512 px photo upscaled 2x, beside a bicubic enlargement of the same detail |
| Video | Cinematic landscape, seamless loop, urban cinematic |
| Video editing | One source clip, restyled or extended |
| Video upscaling | A 480p clip upscaled 2x, beside a bicubic enlargement of the same detail |

Most renders come from the model pages on venice.ai. Where venice.ai has none, the docs render the same suite through the Venice API, with video models on the cinematic landscape prompt only, to keep the clips light.

Models without renders are listed under **No reference renders yet**.

## Performance

Text model pages show time to first token, output speed and uptime for the last 24 hours, measured on Venice traffic from the API, venice.ai and the app. The figures are counts and timings of requests, never their prompts or outputs. They're refreshed every hour, and a page stops showing them once they're more than six hours old.

| Figure | How it's measured |
| - | - |
| Time to first token | The median, from the start of inference to the first token of reasoning or output, including any failover. The 90th percentile is in the agent brief and the data file. Streamed Chat Completions only. |
| Output speed | The median of output tokens, reasoning included, divided by the time from the first output token to the end of the stream. Successful streamed Chat Completions of 10 tokens or more, on the API only, since venice.ai and the app don't record it. |
| Uptime | Successful requests as a share of successful and failed ones, rounded down: a whole percent below 1,000 requests and one decimal from there. 5xx errors, timeouts, streams that break partway, and 401, 402 and 404 responses count as failures. A request that fails over to another provider and succeeds counts as a success. Rate limits (429), geo-blocks (403) and requests rejected as malformed (400, 413, 422) don't count either way. |

A figure needs 20 requests for time to first token and output speed, and 100 for uptime. Below that, its card is left out, and a model without any figures has no performance cards.

Time to first token and output speed charts split the 24 hours into equal periods of 15 minutes, 1 hour, 3 hours, 6 hours or the whole day: the shortest length at which every period with requests has as many as the day's figure needs. Every point is then a real figure on enough traffic, and a model with little of it gets a few long periods, or one flat line at its daily figure. A period without requests, such as before a new model's first, leaves a gap in the line. A model whose periods are longer than an hour shows where its figure falls among the other text models in place of a line, further right being better. They put the median period halfway up and draw anything over twice the median at the top, and hovering or dragging gives each period's figure.

Uptime charts give each quarter hour of the day two thin bars: green when it was up, the warning color when degraded (under 95%), red when down (under 80%), and grey when it had no requests, such as before a new model's first. Below 100 requests, a quarter hour only reads as degraded or down when even the optimistic end of its 95% Wilson interval is under the line, so one failure among a few requests stays green. Hovering or dragging gives each quarter hour's uptime. Below 100 requests, a quarter hour with a failure gives its status instead, since its uptime could give away how many requests it had. On a model whose quarter hours without requests are scattered over more than an eighth of the day, they shrink to a thin line.

Under each figure, time to first token and output speed say where the model ranks among the other text models, and uptime how long it was down or degraded. The page's Compare table gives time to first token and output speed for similar models.

### Planned

> [!NOTE]
>
> Not published yet. This describes what the catalog will show.

Venice will measure the other modalities with synthetic probes, never customer prompts, and publish:

| Modality | Metrics |
| - | - |
| Image | Uptime, generation time for one 1K image (p50 and p95), success rate |
| Video | Uptime, queue time and generation time for a 5-second 720p clip (reported separately), success rate |
| Audio | Uptime, time to first audio, speed factor, success rate |
| Embeddings | Uptime, latency for a 1K-token input, success rate |

Text models will also get time to a 500-token response and cache hit rate, which is `cache_read ÷ (input + cache_read + cache_write)` across all traffic.

## Benchmarks

Text model pages show GPQA Diamond: 198 graduate-level questions in biology, chemistry and physics, four options each, run by Venice through the API on each model as Venice serves it.

* **Score.** A model's score is its run at its default reasoning, or its best run until it has one, and its rank counts every text model with a score. A run at another setting carries it in the name, as Artificial Analysis names configurations: *Kimi K3 (off)*.
* **Price.** Each chart plots every text model with a score against its blended price on Venice, three input tokens for each output token. The shaded corner holds the models that score higher for less; when it's empty, no model on Venice beats this one on both.
* **Confidence.** Each score has a 95% confidence interval, shown when you hover the score and published in the data, so models a few points apart are effectively tied.
* **Broken runs.** A run that scores below chance, 25%, measured a broken setup and is left out.

Benchmarks are chosen for the frontier: still discriminative at the top, resistant to contamination, and runnable against the model as Venice serves it. Every score will carry one provenance label, never averaged together:

* **Venice-verified**: run on the Venice endpoint shown on the page.
* **Independent**: run by a third party, usually on the lab's own API.
* **Lab-reported**: published by the model's creator.

Each score also shows the benchmark and harness version, reasoning effort, test date and a confidence interval. Scores older than 90 days, or superseded by a new benchmark version, are flagged as stale.

| Modality | Planned headline set |
| - | - |
| Text | Artificial Analysis Intelligence Index, plus Humanity's Last Exam, Terminal-Bench, τ³-bench, AA-LCR, IFBench, AA-Omniscience and a Venice Openness Score |
| Image | Human-preference Elo from the Artificial Analysis and LMArena arenas, GenEval 2 and an over-refusal rate |
| Video | Artificial Analysis text-to-video (with and without audio) and image-to-video Elo, LMArena text-to-video |
| Text to speech | Artificial Analysis Speech Arena Elo, word error rate, time to first audio |
| Speech to text | Artificial Analysis word error rate, Open ASR Leaderboard, speed factor |
| Music | Artificial Analysis Music Arena (instrumental and vocals) |
| Embeddings | MTEB Multilingual, RTEB and a Venice held-out retrieval set |

The set is reviewed every quarter. A benchmark becomes a floor check, no longer a headline, once frontier models saturate it or it fails a contamination audit.

## Machine-readable data

The catalog behind these pages is published as JSON at [`/data/model-catalog.json`](https://docs.venice.ai/data/model-catalog.json) and rebuilt with every hourly sync. It suits comparison, analysis and agents; to pick a model at runtime, call [`GET /models`](https://docs.venice.ai/api-reference/endpoint/models/list).

| Field | Contents |
| - | - |
| `version` | Schema version, currently `1` |
| `generatedAt` | ISO 8601 time of the last build that changed the data |
| `counts` | Model and family totals, overall and per modality |
| `providers` | Model makers keyed by slug, with `name` and `logo` |
| `families` | Array of families: `slug`, `name`, `modality`, `task`, `provider`, `description`, `primary` (the default variant's ID), `variants` (model IDs), `created` and `updated` (Unix seconds), `privacy` (every tier offered), `counterpart` (the slug of a model's E2EE build, or of an E2EE build's model), `uncensored` and `openWeights` |
| `models` | Object keyed by model ID: `name`, `type` (as in `GET /models`), `modality`, `task`, `variant`, `provider`, `family` (its family's slug), `privacy`, one block of limits and capabilities named for the modality (`text`, `image`, `video`, `audio` or `embedding`), `pricing` in the native unit, `headline` (the reference price above), `media` (reference renders) and `benchmarks` (a text model's entry in the benchmark scores below) |
| `benchmarks` | Benchmark definitions keyed by ID, each with `name` and `source`: `venice` for Venice's own runs through the API |
| `mediaSuite` | The reference prompt suite, by modality |

Fields without a value are left out. Prices are in USD.

The [performance figures](#performance) are a separate file, [`/data/model-performance.json`](https://docs.venice.ai/data/model-performance.json), also refreshed with every hourly sync:

| Field | Contents |
| - | - |
| `version` | Schema version, currently `1` |
| `source` | Where the figures were copied from |
| `generatedAt` | ISO 8601 time Venice computed the figures |
| `window` | `start` and `end` of the 24 hours |
| `models` | Object keyed by model ID: `uptime` (the 24-hour uptime, rounded down: a whole percent below 1,000 requests and one decimal from there), `ttftMs` (time to first token in milliseconds, `p50` and `p90`, for `1h`, `4h` and `24h`), `tokensPerSecond` (median output speed in tokens per second for the same windows), `periods`, what the time to first token and output speed charts draw: `ttftMs`, `tokensPerSecond` and `uptime`, each with `minutes`, the period length, and `values`, one figure per period, oldest first, or null for a period without requests, and `uptimeStatus`, what the uptime chart draws, with each quarter hour of the window as one character, oldest first: `u` up, `d` degraded (under 95%), `x` down (under 80%) or `-` no requests, and `uptimeQuarters`, each quarter hour's uptime as a whole percent, oldest first; below 100 requests it's only given as 100, where nothing failed, and is otherwise null. A figure without enough requests is left out. |

Venice's own benchmark scores are a separate file as well, [`/data/model-benchmarks.json`](https://docs.venice.ai/data/model-benchmarks.json), which the hourly sync updates when a new run lands:

| Field | Contents |
| - | - |
| `version` | Schema version, currently `1` |
| `source` | Where the scores were copied from |
| `generatedAt` | ISO 8601 time Venice published the scores |
| `benchmarks` | Benchmark definitions, as in the catalog |
| `results` | Object keyed by model ID, then by benchmark ID: one run for each reasoning setting, ordered `off`, `default`, then efforts from lowest to highest. Each run has `reasoning` (`off`, `default` when the run sent no reasoning parameter, or the `reasoning_effort` it set), `accuracy` (the percentage of samples answered correctly), `ci95` (half the width of the 95% confidence interval, in points), `samples`, `outputTokens` and `reasoningTokens` (per sample, `null` when the run didn't count them), `measuredOn` (the run's UTC date) and `harness` (the version of the harness that ran it). |

## Data sources

The catalog is built from public endpoints you can call yourself:

* [`GET /models`](https://docs.venice.ai/api-reference/endpoint/models/list) for specs, capabilities and prices.
* [`POST /video/quote`](https://docs.venice.ai/api-reference/endpoint/video/quote) for video prices.
* [`GET /models/traits`](https://docs.venice.ai/api-reference/endpoint/models/traits) for defaults such as `default_code`.

Prices are in USD. DIEM is billed at parity.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.