Pricing and limits
Prices
Prices are in US dollars per million tokens and are read from GET /v1/models when this page is published and again when you open it. You are billed on the usage object returned with every response: prompt_tokens at the input price, of which prompt_tokens_details.cached_tokens at the cached input price, and completion_tokens at the output price. Reasoning tokens count as output tokens.
| Model | Input | Output | Cached input |
|---|---|---|---|
orion-pro | $0.144 | $1.50 | $0.036 |
orion-plus | $0.101 | $0.60 | $0.025 |
qwen3.8-27b | $0.144 | $1.50 | $0.036 |
qwen3.6-35b-a3b | $0.101 | $0.60 | $0.025 |
paddleocr-vl-1.6 | $0.016 | $0.016 | n/a |
Read from the API (GET /v1/models) when this page was published, on 6 November 2026, 19:49 UTC.
Images count as prompt tokens. A full page sent to paddleocr-vl-1.6 for document OCR is about 1,250 prompt tokens.
These are the prices of direct access to the API with a Serenity Edge API key. An enterprise contract may set committed-use rates. With a key from a Serenity Star account, Serenity Star bills your usage at the prices of that account. Through a router or marketplace, that platform bills you under its own terms and shows its own prices.
Cached input
When the beginning of a prompt repeats across requests (a long system prompt, a shared document, the earlier turns of a conversation), the matching prefix can be served from the prompt cache and is billed at the cached input price. The number of cached tokens is reported in usage.prompt_tokens_details.cached_tokens (usage.input_tokens_details.cached_tokens on the Responses API). To benefit, keep the stable part of the prompt at the start and the variable part at the end.
The cache works in blocks of tokens, so a prefix is cached only when it repeats over more than about 2,000 tokens (about 4,000 on orion-plus and qwen3.6-35b-a3b), and the cached part is a whole number of blocks; a shorter prompt is billed entirely at the input price. Every request of a conversation is sent to the server that already holds its prefix, so the earlier turns of a conversation are cached as long as you send them unchanged.
Decision models
Decision models are in public preview. Their availability will be announced in the release notes.
Decision models are billed on input tokens only: usage.input_tokens of each reply at the input price below. Output is not billed, and there is no cached input price. The model reads the input together with each question, so the input tokens of a request grow with the number of questions as well as with the length of the input. Prices are in US dollars per million input tokens and are read from GET /v1/models?format=openai when this page is published and again when you open it. On orion-compass-flash and d3, the tokens of a request's images are input tokens too: usage.input_tokens counts them, and usage.input_tokens_details.image_tokens (usage.image_tokens on POST /v1/systemone) shows their part.
| Model id | Context | Reads | Input | Output | Endpoints |
|---|---|---|---|---|---|
d3also vllm-sr/d3 | 24,576 | textimage | $0.042 | Free | /v1/decisions/v1/systemone |
orion-compassalias of orion-compass-26.1 | 32,000 | text | $0.034 | Free | /v1/decisions/v1/systemone |
orion-compass-flashalias of orion-compass-flash-26.1 | 32,000 | textimage | $0.017 | Free | /v1/decisions/v1/systemone |
Read from the API (GET /v1/models?format=openai) when this page was published, on 6 November 2026, 19:49 UTC.
A decision request whose input and questions do not fit the context length is refused with code: "context_length_exceeded" rather than truncated. Rate limits and capacity work as for chat completions: see below.
Embeddings, rerank and redaction
The models of POST /v1/embeddings, POST /v1/rerank and POST /v1/redact are billed on input tokens only, at the price below; output is not billed, and there is no cached input price. Prices are in US dollars per million tokens and are read from GET /v1/models?format=openai when this page is published and again when you open it. See Embeddings, rerank and redaction for worked examples.
| Model id | Input | Endpoint |
|---|---|---|
privacy-filteralso openai/privacy-filter | $0.009 | /v1/redact |
qwen3-embedding-0.6balso qwen/qwen3-embedding-0.6b | $0.008 | /v1/embeddings |
qwen3-reranker-0.6balso qwen/qwen3-reranker-0.6b | $0.008 | /v1/rerank |
Read from the API (GET /v1/models?format=openai) when this page was published, on 6 November 2026, 19:49 UTC.
| Route | Billed tokens | Per request |
|---|---|---|
POST /v1/embeddings | usage.prompt_tokens of the answer: each input's own tokens, as the model counts them | At most 512 inputs and about 300,000 tokens (a quarter of the characters), each input read up to its first 8,192 tokens; body up to 4 MB |
POST /v1/rerank | Estimated per document as ceil((characters(query) + characters(document)) / 4), added up and returned in usage | At most 1000 documents, a query of 4096 characters and about 300,000 tokens (the estimate in the previous column); body up to 4 MB |
POST /v1/redact | Estimated as ceil(characters of all inputs / 4); the answer has no usage | At most 256 inputs; body up to 192 KiB (196,608 bytes) |
Characters are Unicode code points, not bytes. If an embeddings answer ever comes without usage, it is billed on an estimate instead: a quarter of the characters of each string, rounded up. A request over a limit is refused before it reaches the model: HTTP 400 for too many inputs or documents, HTTP 413 for a body that is too large. Rate limits and capacity work as for chat completions: see below.
Context and output limits
The context window (input plus output) and the maximum output (max_tokens) of each model are shown in the catalogue and returned by GET /v1/models. A request whose messages exceed the context window is rejected with HTTP 400. A response that reaches max_tokens or the end of the context window returns finish_reason: "length".
Rate limits
Every API key has a request-per-minute and a token-per-minute allowance. When you exceed it the API returns HTTP 429 with a Retry-After header stating how many seconds to wait, and an error object of type rate_limit_error.
Handle 429 with exponential backoff and honour Retry-After. The OpenAI SDKs retry 429 automatically; see Errors and rate limits for details and for how to request a higher limit.
Capacity
Serenity Edge runs on Substrate AI's own GPUs in Spain, not on a hyperscaler. Capacity is added in steps as new hardware comes online. During peaks the API may respond with HTTP 429 and a Retry-After header rather than degrade latency for everyone; handle it like any other 429. If you need guaranteed throughput, an enterprise contract reserves capacity for you.