Read the record.
Vitna publishes what AI infrastructure costs, with the document behind every figure. These pages say what the record holds, what each word in it is allowed to mean, and how to read all of it over HTTP without a key.
There is no key to obtain and no quota to negotiate. If you can reach the host you can read the record, and the same figures the boards print come back as JSON.
curl https://vitna.ai/api/v1/marketsThe quickstart walks six requests end to end, and the API overview covers the envelope, caching and the error codes every endpoint shares.
Start here
What the API looks like in six requests.
- Cite a figureEvery price on every board carries a permanent, dated citation. This page is what that citation is, how to get one, and how long it will keep resolving, which is a promise rather than an intention and is written here because it has to exist before the first citation is minted rather than after.
- One key for the hosted APIsAn org holds one key for Vitna's hosted APIs. Search, the Web APIs and the Unblocker each accept it as Authorization: Bearer vitna_key_..., and each checks it with vitna.ai, where the key lives as a hash beside the org's other keys. During the beta an operator mints it.
- QuickstartEvery read endpoint on vitna.ai is public and needs no key. There is no signup, no token, and no rate limit to negotiate. If you can reach the host you can read the record.
- Verify a figure yourselfThe whole claim of this record is that you do not have to trust it. This page is that claim carried out, end to end, with nothing taken on faith.
Concepts
The vocabulary the record is written in, and what each word is allowed to mean.
- The modelVitna is a record of what AI infrastructure costs, and an engine that decides when a change to a production stack is worth making. Two systems, one repository, one database with a schema each.
- AttestationEach day's observations hashed into a Merkle root and signed with Ed25519, so that an edit made afterwards has to contradict something already published.
- Component classThe top-level division of the market. A class is a kind of thing you buy, with one unit it is ultimately bought in.
- Workloads, triggers and decisionsAperture, the engine half. Witness records what things cost; Aperture decides whether a change is worth making, and records that nobody has acted on it yet.
- DimensionWhat a price is charged by. A sku does not have "a price"; it has a price per dimension, and most skus carry several.
- EvidenceThe archived document a figure was read from, addressed by the sha256 of its bytes.
- Market eventA published statement that something happened in the market. The rows the market log renders and the feed carries.
- ObservationOne figure, parsed out of one document, at one moment. The atom of the record.
- Price periodOne stretch during which a price did not move. The history unit.
- Provider termWhat a provider published about how it handles the work, beside what it charges for it.
- Reference rateOne number per product per day: the median list price among the providers publishing one, by a rule with no judgement in it.
- SkuThe unit Vitna prices: one thing, sold by one provider, that you could buy.
- SourceOne fetchable document, and the adapter that knows how to read it.
API v1
Every read endpoint. Public, keyless, and answering the same figures the boards print.
- API v1JSON over HTTP. Reading the public record takes no key, no signup and no quota. Base URL https://vitna.ai/api/v1.
- PricesCatalog, benchmarks and capabilityMirrored model metadata, Hugging Face weight licences, route speed measurements, multi-seller endpoint offers, openly licensed benchmark boards, and Vitna's IRT capability scale. Kept separate from /api/v1/markets so meta.provenance always distinguishes mirrored third-party data from Witness first-party provider observations.
- PricesHistorical data exportsPaginated bulk export of Witness first-party datasets (price-periods, observations, rates, events, and provider-terms) in JSON, JSONL (application/x-ndjson), or CSV (text/csv) for Deploy and Enterprise organisations.
- PricesLiteLLM cost mapWitness's attested language-model and retrieval rates rendered in the JSON dictionary format LiteLLM's --model_cost_map_url (LITELLM_MODEL_COST_MAP_URL) loads directly, with a vitna provenance block on every entry.
- PricesMarketsEvery component class Vitna prices, with counts and freshness. The index of the record.
- PricesProvidersEvery company whose own pages Vitna reads a price from, with the pages read, the markets each sells into, and any registered products no longer on the board.
- PricesQuote CheckEvaluate a vendor quote in memory against historical published list prices, peer spreads, and reference rates.
- PricesReference ratesThe published reference rates: one number per product per day, the median list price among providers publishing one.
- PricesSku historyEvery price period recorded for one sku.
- PricesSnapshotAll ten board documents in exactly the shape app/data/ holds them: the model board, the GPU board, and the eight meter boards.
- PricesSpreadsWhat several providers charge for the same product, cheapest first, with the percentage between the low and the high.
- PricesTapeEvery current price in one class, flattened to one row per priced cell.
- PricesProvider termsWhat providers have published on their own domains about how they handle customer work: retention, training use, processing regions, and bring-your-own-key support. The read surface for provider terms.
- The logEventsThe market log as data. Curated and detected rows merged, newest first.
- The logFeedJSON Feed 1.1. The market log plus the triggers that fired and the decisions the engine proposed, in something a reader, a bot or a chat channel can subscribe to.
- VerificationAttestationsThe signed daily Merkle roots, newest first, with everything a check needs.
- VerificationCitationsOne observation in the three paste-ready citation forms /cite/{id} prints (reference, footnote, schedule), alongside the figure's provenance fields and signed-day status. See citing a figure for the permanence rules that govern these URLs.
- VerificationEvidenceThe record of one archived document, and behind a token, the document itself.
- VerificationSigning keysEvery key the record acknowledges, what each one is for, whether it has been retired, and how much it provably signed.
- VerificationObservation proofThe path from one observation up to a signed root. The other half of the attestation.
- The engineCollecting a signed artifactGET /api/v1/artifacts lists what has been signed for your organisation, and GET /api/v1/artifacts/{id} hands over the bytes, exactly as they were signed.
- The engineStateless audit attestation packVerify a vitna.audit-pack.v1 document across all six cryptographic and governance layers, or assemble an inline audit pack from a vitna.stackfile.v1 payload in memory with no API key and zero retention.
- The engineStateless stack decision checkEvaluate an inline workload, candidate model list and evaluation measurements against live Witness prices and provider compliance terms in memory, with no API key and zero retention.
- The engineDecision packOne accepted or recorded decision as a standalone, signed audit pack: the decision, the exact price periods and evidence it read, the observation leaves with their Merkle hashes, and the canonical digest of the whole, so the pack can be verified offline without the record.
- The engineModel Context Protocol (MCP)Keyless Streamable HTTP MCP endpoint (2025-03-26 and 2024-11-05) exposing ten read-only and zero-retention tools over Vitna's first-party Witness market record, provider compliance terms, three-provenance SKU capabilities, cryptographic citations, stack decision engine, rollout watchdog, compound pipeline analyzer, and offline audit pack verifier.
- The engineHeadless artifact signing requestsQueue an asynchronous request for the isolated signer to rebuild and Ed25519-sign your organisation's standing routing policy or environment config, and poll until the artifact settles.
- The engineOrganisation audit attestation packExport a read-only vitna.audit-pack.v1 procurement, FinOps, and model-governance attestation pack across an authenticated organisation's registered workloads, standing decisions, signed policy, and attested Witness prices.
- The engineWorkload counterfactual costCompute what a recorded usage window of one of your organisation's workloads would have cost at historical Witness list prices had it run on another SKU.
- The engineCI evaluation evidenceRecord evaluation measurements from CI pipelines and read back historical measurements for your organisation's workloads, with built-in normalization for Promptfoo, Braintrust and UK AISI Inspect AI outputs.
- The engineOrganisation dependency and deprecation exposureRead your organisation's live workload-to-SKU-to-provider dependency graph, provider blast-radius concentration, stale standing decisions and upcoming model deprecations as structured JSON.
- The engineYour organisation's feedThe triggers that fired on your organisation's workloads and the decisions the engine proposed for them, newest first, as a feed a reader or a chat channel can subscribe to. It is private: the address is the permission, and an owner of the organisation gets it from the console.
- The engineOrganisation API keysList active and revoked organisation API keys without exposing key hashes, and soft-revoke compromised or retired keys with an audit reason.
- The engineOrganisation membersList active organisation members, add or re-admit GitHub accounts on any plan, and soft-remove members with last-owner protection.
- The engineOrganisation compound pipelineInspect the cross-layer Bill of Materials, bottlenecks, decision-ready switches, and eligible class-peer exploratory levers across an authenticated organisation's registered workloads.
- The engineOrganisation StackfileExport your organisation's live register as a canonical vitna.stackfile.v1 JSON document, preview a deterministic reconciliation plan (dryRun: true), or apply declarative register updates over HTTP.
- The engineOrganisation rollout watchdogInspect standing-decision drift, shadow rule promotion readiness, and routed canary health across an authenticated organisation's active workloads.
- The enginePolicy drift webhooksRegister, test and soft-disable HMAC-SHA256 signed webhook endpoints for policy drift, newly signed policy bundles and fired price watches on Deploy and agreement organisations.
- The engineOrganisation workloadsList, create, edit and transition workloads in your organisation's register over HTTP, including reversible pausing and permanent archiving that free active workload slots without erasing decision history.
- The engineStateless compound pipeline analysisEvaluate a multi-stage, multi-class AI pipeline Bill of Materials, per-run trace attribution, compound reliability, and cross-layer spend optimization in memory with no API key and zero retention.
- The engineProposalsThe decision register: what the engine proposed, what a person ruled, and the exact rows each brief was derived from.
- The engineStateless invoice reconciliationReconcile a usage window and optional stated vendor invoice lines against historical Witness list-price periods in memory, deriving exact list-cost bounds and implied enterprise discounts with zero retention.
- The engineRelay spreads and Anchor manifestsKeyless, ETag-cached registry feeds consumed by vitna-relay for wholesale cloud arbitrage and by vitna-anchor for verified 4KB DMA local checkpoints.
- The engineRouter challengeEvaluate in memory whether handing model selection to a dynamic router (openrouter/auto, martian/model-router, notdiamond/custom-router, routellm/mf, or a custom router) beats naming a fixed SKU, with zero retention. The HTTP surface for Router Challenge (#72).
- The enginePushing usageThe one write route this API mounts, and the only route a machine authenticates to. A runtime pushes what its own ledger says served each lane on a day that has ended, and each batch lands as readings on /console.
- The engineStateless rollout watchdogEvaluate standing-decision drift, shadow rule promotion readiness, and routed canary health in memory against Witness list prices, provider compliance terms, and three-provenance SKU capabilities, with no API key and zero retention.
- The engineWatchesWhat each workload is watching, and what has already fired.
- StatusHealthWhether this instance is up, and what it found when it reached for the database.
- StatusSource healthEvery source Vitna reads, and whether it is still answering.
Routing
How an accepted decision becomes a value a machine loads, and how the record learns whether it took.
- RoutingHow an accepted decision becomes a value a machine loads, and how the record finds out whether the change actually took.
- Rendering a policy for a gateway you already runA signed policy is a document a Vitna runtime executes. An adapter renders that same document as the configuration of a gateway you run instead, so one accepted decision configures whatever is already in your request path rather than asking you to adopt something new.
- Audit and procurement attestation packsBundle an organisation's declarative Stackfile, standing routing decisions, signed runtime policy envelope, CI policy lock, RFC 6962 Witness price observation Merkle proofs, provider compliance terms, three-provenance SKU capabilities, rollout watchdog status, and compound pipeline Bill of Materials into one self-contained, offline-verifiable vitna.audit-pack.v1 file.
- Three-provenance capability eligibilityCapabilities and runtime speed constraints narrow which candidates may serve a workload before cost per successful unit is weighed, and each constraint is bound to the provenance class that can honestly answer it.
- Emitting a routing configaperture:config renders an organisation's accepted decisions as a signed environment fragment.
- Connected accountsAn org connects its OpenRouter account to Vitna from /console, by OAuth PKCE. Vitna is never given a provider API key, and there is no field anywhere on this site that would accept one.
- Composing the register from the consoleAn owner of an org can enter a workload, put a sku in play, record a measurement and arm a watch at /console, instead of running the commands at a prompt on the box.
- Ruling from the consoleAn owner of an org can accept or refuse an open proposal at /console, instead of running `aperture:accept` at a prompt on the box.
- Delivery targetsWhere a workload's accepted decision gets applied. Without one, a decision is only readable; with one, it is emittable.
- Fallback chainsWhat may serve a lane when the model a decision named cannot.
- Running the hosted routerrouter:start serves an OpenAI-compatible endpoint for several organisations at once, resolving each request against that organisation's own signed policy and paying for it with that organisation's own delegated OpenRouter key.
- Model idsThree names exist for one model, and only two of them are the registry's.
- Did the decision do what it saidA decision predicts. An imported usage export observes. This is the two of them side by side, which the record could always answer and never had to.
- Multi-class unit profiles and compound pipelinesEvaluate end-to-end AI workflows that fan out across multiple component classes, attribute runtime x-vitna-run trace volume back to each stage, and separate decision-ready migrations from exploratory class-peer levers.
- Emitting a routing policyaperture:policy renders an organisation's accepted decisions as a signed policy document, which is what a Vitna runtime loads and resolves requests against.
- Vitna routerBuilt on 2026-08-31, ahead of the preconditions this page sets out, on the owner's instruction. The software exists: npm run router:start runs a multi-tenant router serving C1, and Running the hosted router is how. What does not exist is the product. Vitna operates no traffic for anybody, the three preconditions in RUNTIME.md phase R5 are still unmet, and this page remains the design to hand a reviewer rather than a description of a service somebody can buy.
- Router Challenge (#72)A router executes a routing policy per request. Vitna determines whether handing the choice to a router beats naming a model.
- Rules within a laneThe per-request question, answered without an oracle: a declared predicate on an observable request attribute, routing to a named sku, shadow first.
- Rotating the seller, not the modelA lane may name several hosts of the same weights and let a request go to the cheapest one that is up, without a new decision, because nobody decided to serve a different model.
- Signing an artifact without an operatoraperture:sign answers a queue of asks for signed artifacts, rebuilding each one from the record rather than signing what it was handed, so that a config or a policy can reach a customer without somebody standing at a prompt.
- Declarative Stackfile and CI policy lockCheck your organisation's workload register into git as vitna.stack.json (vitna.stackfile.v1), preview and apply register changes deterministically, and gate deployments in CI with vitna-runtime-lock and vitna.lock.json.
- Importing usageaperture:usage:import reads a consumer's own usage export back into the record, so it can say what actually served a workload.
- Verifying a routing configChecking a file you were handed, without needing the database or the key that made it.
- Rollout and decision watchdogDecision-oriented observability over live workloads and active lane rules: whether current prices, compliance terms, three-provenance capabilities, and runtime telemetry still support the standing decision, and where each shadow or route rule stands on the canary ladder.
Runtime
The optional process that applies a decision per request, on your own infrastructure and never on ours.
- The runtimeAn optional process that applies an accepted decision per request, on your own infrastructure. It is the second way to consume a decision, beside the config a consumer loads into a variable it already reads.
- The response cacheA repeat of a deterministic request, answered from memory rather than by a provider. Off unless you turn it on, and never a saving.
- Putting a coding harness on a lane*An operator note.* The launcher is not in the published package: it runs from a checkout of Vitna's private repository, as does the local lane it looks for. Outside Vitna, point the harness at a runtime you installed yourself, with the base URL Serving a lane gives.
- Installing the runtimeGetting from nothing to a served lane, on your laptop, your box, or your own cloud account.
- The ledgerOne line per request, appended to the file VITNA_LEDGER names. It is yours, on your disk, and it moves only when you move it.
- A lane on your own machineAn operator note: one command from a workload in the register to a runtime answering on the same machine, run from a checkout of Vitna's repository, which is private. It is for Vitna's own operators. Outside Vitna, the runtime is installed from npm with a policy the console signs, which is Installing the runtime.
- Measuring your unit profileA unit profile is how many tokens one call on a lane actually consumes. It is the bridge between a published price and a cost per unit: input tokens per unit, multiplied by a price per million input tokens, is what one unit of that work costs at list.
- Pushing the ledgerSending a runtime's closed days to Vitna, deliberately, as a command of its own.
- RedactionKnown credential formats lifted out of a request before it leaves your machine, and put back into the answer, streams included. Off unless you turn it on, for the lanes you name or for traffic that names a model, except in Relay, which turns it on for you.
- Relay: the runtime with no policyRelay is vitna-runtime started with no policy at all, for a developer who wants a local gateway today and a register later, or never. Every request is served as exactly the model it names, on your own keys, and every one is a line in a ledger on your disk.
- Per-request auto-routing with vitna-routevitna-route selects the model and reasoning effort for each request deterministically from structural counts of the prompt, preserves prompt caches across multi-turn conversations, and requires an Aperture-signed policy pinned by VITNA_PUBLIC_KEY before routing live traffic.
- Serving a laneStarting a runtime against a signed policy, the two request dialects it answers, and how a lane reaches its model, fails over and stays inside the provider allowlist.
CLI
Every command an operator runs, and what each one refuses to do.
- The CLIEverything an operator does to the record is a command, run from a checkout with the environment sourced. There is no admin UI, and that is a property of the design rather than a gap.
- Access commandsWhich orgs exist, who may read them at /console, and how a session is opened or revoked.
- npm run db:generate, npm run db:migrateGenerating a migration from the schema and applying it, forward only, with the grants that carry the record's rules kept narrow.
- npm run event:addAdd one curated market event.
- Push keysWho may land a reading over the network, per org, minted and revoked at the prompt. The web process authenticates against these and cannot mint one. With console keys on, an owner can revoke one from the console, and can mint a platform key there through a separate minter (below).
- The standalone scriptsThe mirrors that write app/data/, the reconcilers that run behind them, and the rest of what is run with node rather than through npm.
- Witnessnpm run witness:attestHash a day's observations into a Merkle root and sign it.
- Witnessnpm run witness:collectOne collector pass: fetch every enabled source, parse it, archive it, and write what changed.
- Witnessnpm run witness:ratesPublish yesterday's reference rates.
- Witnessnpm run witness:rebuild-periodsReplay every observation into price periods.
- Witnessnpm run witness:seedThe registry: classes, providers, sources, dimensions, skus, and the curated market log.
- WitnessRecording a provider termEntering, by hand, what a provider published about how it handles the work: retention, training use, processing regions, whether a key you hold is accepted. Each reading is taken from a page on the provider's own domain.
- Skus and discoverynpm run sku:candidatesThe priced rows the collector saw that the registry does not track.
- Skus and discoverynpm run sku:linkClose a candidate against a sku the registry already holds.
- Skus and discoverynpm run sku:promoteRegister a candidate as a sku.
- Skus and discoverynpm run sku:rejectRule a candidate out.
- ApertureAudit attestation pack CLIExport, sign, and verify self-contained vitna.audit-pack.v1 procurement, FinOps, and model-governance attestation packs from the register, from an offline Stackfile, or in an air-gapped CI runner.
- ApertureHow much of a bill the record can priceOne window of somebody's spend, bucketed by whether the record holds a figure for it.
- ApertureWhat it would have cost somewhere elseOne window of a workload, priced on a sku that did not serve it.
- ApertureDecidingRunning the engine, and ruling on what it proposes.
- ApertureCandidates and evidencePutting a sku in play, and recording what was measured about it.
- ApertureCompound pipeline CLICompute a multi-stage, multi-class AI pipeline Bill of Materials, attribute empirical x-vitna-run trace fan-out from a runtime ledger, discover eligible lower-cost Witness class peers, and enforce per-run or monthly spend budgets in CI.
- ApertureYour own infrastructureRegistering something this organisation runs that no provider publishes a price for, and entering what it costs.
- ApertureSeeding and notificationLoading the engine's reference data, and draining the outbox into the feed that stands in for email.
- ApertureTrigger commandsArming a watch on the record, and seeing what has fired.
- ApertureRollout and decision watchdog CLIEvaluate standing-decision drift, shadow rule promotion readiness, and routed canary health across an organisation's active workloads or offline against a checked-in Stackfile and runtime ledger.
- ApertureWorkload commandsEntering and correcting the things you run.
Operations
Serving, deploying, collecting and backing up the one box this runs on.
- OperationsHow the site is served, deployed, collected and backed up. One box, one Node process, no orchestration.
- BackupsA nightly unit dumps the database, keeps a fortnight locally, and mirrors both the dumps and the evidence tree off-box.
- Self-service checkoutHow somebody becomes a customer without anybody at Vitna doing anything, and what the box needs configured before they can.
- The collectorA oneshot unit fired hourly with jitter, running one collector pass out of the deployed checkout.
- DeploysPush-based. The box never talks to GitHub.
- Rotating a signing keyReplacing the key that signs customers' policies without refusing a single running runtime, and what a compromise needs instead.
- Rolling backMost failures roll themselves back. One kind needs a person.
- Verifying a deployA push that exits zero is not a deploy. Three checks say which commit is live.
Search
The search API beta: web discovery, focused crawling, budgets, deployment, providers, and client keys.
- Vitna SearchPrivate beta. A separate search API for agents with independent Google/Bing SERP retrieval and Vitna's own crawler and web index. SERP requests return actual search-engine organic listings; indexed search and cited research use successfully indexed pages. It includes a browser interface, dedicated client keys, and shared request limits. The private-key beta is hosted at https://search.vitna.ai, with an API reference at /docs. Its product page and a playground are at /search on vitna.ai. Keys are issued by invitation, requested at vitna.ai/start. Customer signup and search billing are not enabled.
- Run the general web betaVitna Search can grow its own index across public websites, keep a durable crawl queue, and serve authenticated searches without a paid search provider. This is a bounded beta with limited coverage. The API is deployed at https://search.vitna.ai on a reused Virginia OVH server, with private R2 backups. No additional OVH instance was purchased.
- Grounding checkplatform/search/grounding.mjs decides, segment by segment, whether an answer a model wrote from Vitna Search evidence is supported by the verbatim passages it cites. It is deterministic and lexical: it uses no model and no network, and it checks that what a sentence states occurs in the cited passages, not what the sentence means.
- Vitna Search Vertical IndexesVitna Search exposes specialized vertical corpora alongside the default web index through a single index field on /v1/search, /v1/similar, and /v1/extract:
- Migrate Bright Data and Live/Hybrid clientsVitna retrieves actual Google and Bing organic SERPs through its own transport and parser at POST /v1/serp, with a URL-based compatibility path at POST /request. The former Bright Data search adapter has been removed. Native indexed search and cited research remain separate capabilities. This page keeps its existing URL to help older clients migrate.
- Run a focused search indexVitna can crawl selected public AI documentation, keep an independent keyword index, and serve it through the search API. An OVHcloud Public Cloud instance can run the service and crawler; Cloudflare R2 can hold standalone snapshots. The deployment files are prepared locally. No cloud resources, DNS records, R2 uploads, or credit spending have been created by this implementation. For cross-site discovery, persistent crawl budgets, API quotas, and the Virginia deployment package, use the general web beta.
- Google and Bing SERP retrievalVitna's SERP API retrieves actual Google or Bing search result pages through Vitna's own transport and parser. It returns parsed organic and rich SERP features (or the fetched HTML) without calling Bright Data, supporting web, news, images, videos, and shopping verticals alongside SerpApi-compatible query aliases and output shapes.
Web APIs
Read, extract, map, crawl, monitor, and capture the web through one authenticated API suite.
Unblocker
The browser-backed web access alpha: rendering, outputs, proxies, keys and deployment.
The whole corpus in one fetch.
For anything that would rather read once than crawl, all 145 pages are also published as plain text: an index with one line per page and its summary, and every page concatenated.
Both are generated from the same Markdown these pages render, so an agent and a reader are looking at one corpus rather than two that drifted.
