> ## Documentation Index > Fetch the complete documentation index at: https://docs.capriole.ai/llms.txt > Use this file to discover all available pages before exploring further. # How Capriole AI Works Across Different Model APIs > A technical look at how Capriole AI supports OpenAI Responses, Chat Completions, Anthropic Messages, model aliases, usage, and fallback. Capriole AI provides one account and API key across supported model families. Premium includes 5 million monthly charged API tokens alongside unlimited browser chat, so the same low-cost membership can cover applications, coding agents, and everyday chat. Capriole maintains four public paths: OpenAI Responses, OpenAI-compatible Chat Completions, Anthropic Messages, and a simple Capriole-native chat endpoint. The shared account and billing layer sits above those protocol-specific routes. ## Why this makes Capriole more useful One USD 8 Premium membership covers unlimited browser chat across the supported Premium model set, 5 million monthly charged API tokens, and six maintained coding-agent paths. Applications keep the protocol they already use, while the user keeps one Capriole account, key, balance, and billing page. This is the practical advantage over assembling provider accounts separately. The [dated cost comparison](/articles/ai-api-cost-comparison) also shows Capriole at USD 8 for each tested 5 million-token workload, compared with USD 15 to USD 90 for direct paid Standard pricing and USD 15.83 to USD 94.95 through OpenRouter after its published credit-purchase fee. ## The public paths | Path | Intended contract | Typical use | | --------------------------- | ---------------------------------- | -------------------------------------- | | `POST /v1/chat` | Capriole-native text request | Simple application calls | | `POST /v1/chat/completions` | OpenAI-compatible Chat Completions | Compatible clients and agents | | `POST /v1/responses` | OpenAI Responses | Responses-based applications and Codex | | `POST /v1/messages` | Anthropic Messages | Claude-native clients and Claude Code | Successful routed responses and streamed events remain in the protocol the client requested. A Responses payload is not converted into Chat Completions on the way back. An Anthropic Messages stream is not repackaged as OpenAI output. This preserves the protocol-specific behavior that Responses, Messages, and Chat Completions clients expect. The shared layer handles access and accounting. Each public route keeps the request and response contract its client expects. The model groups are route-specific compatibility sets, not a hierarchy; a model may appear on more than one supported route when it implements each contract. ## Why one endpoint is not enough Model families disagree about more than field names. OpenAI Responses represents output as typed events and items. Anthropic Messages uses its own content blocks and streaming events. Chat Completions has another request and response shape. Reasoning controls, tool calls, usage data, errors, and token-counting behavior also differ. A shallow adapter can make a simple text prompt work. Coding agents and production clients expose the missing details quickly. They depend on streaming order, tool-result turns, usage metadata, and model-specific controls. Capriole therefore owns multiple protocol-preserving routes behind one authentication and billing layer. ## One key, explicit model selection All public generation routes use the same Capriole API key and account balance. The requested model still has to belong to the selected protocol. For example, the Responses path accepts the maintained OpenAI alias and supported Responses-compatible OpenAI models. The Messages path accepts the maintained Claude alias and supported Claude Messages model IDs. Compatible chat paths can expose a broader set of public chat models. If a model is not valid for the chosen route, the request should fail validation. Capriole does not quietly remap an unsupported retired key to something else. That explicit failure is safer than returning an answer from a model the caller did not request. ## Latest aliases and reproducible IDs Capriole exposes maintained aliases such as `openai-latest`, `claude-latest`, and `google-latest` on the public paths that support them. Aliases are resolved before upstream dispatch. Usage, quota, and fallback records are attached to the resolved canonical model rather than an ambiguous “latest” bucket. Use an alias when you want Capriole's maintained default to move with supported releases. Use a concrete model ID when the exact version is part of the result and must remain reproducible. The [List models endpoint](/api-reference/endpoint/get) is the current public inventory. Do not assume a model shown in browser chat is automatically valid on every API protocol. ## Fallback happens before the response begins For supported routes, Capriole can attempt another configured source when the first source fails before response bytes have been sent. Once a streamed response has begun, switching sources would risk duplicated or contradictory output. Automatic fallback only runs before output starts. It cannot hide every provider failure or change models halfway through a response. The requested model key is preserved through a supported source fallback. Capriole changes the delivery source, not the user's stated model choice. Browser chat can separately offer optional model auto-switching and [manual model changes inside a conversation](/articles/switch-models-mid-chat). Those are workspace behaviors, not the raw API fallback contract. ## Usage remains visible Programmatic workloads are metered. Capriole records usage from the metadata supplied by the matching protocol, including completed streamed responses when usage is available. Premium currently includes **5 million charged API tokens per month**. Capriole counts uncached input and output at 100% and cached input at 10% for this balance. Additional token packs are available as top-ups. The unlimited part of Premium applies to browser chat across the supported Premium model set, not to API or coding-agent traffic. The [charged-token article](/articles/charged-tokens) gives the exact formula, rounding rule, and reproducible examples. Browser chat and automated API workloads use separate allowances. A coding agent processing millions of tokens draws from the visible charged-token balance. ## What the unified layer actually provides The useful common layer is not one response schema. It is the surrounding product contract: * one Capriole account and API key; * one visible API balance; * maintained model aliases; * validation against the selected protocol; * supported source fallback before output begins; * usage accounting against the resolved model; * documented setup for applications and coding agents. The protocol remains explicit because clients depend on it. ## How we test compatibility Capriole documents a route as supported after its protocol contract and a representative real client flow both pass. A successful text prompt is an initial check. Streaming, tool-result turns, alias resolution, usage accounting, and negative protocol tests provide the rest of the evidence. As of 2026-08-10, the focused public-route and file-conversion suites had completed **68 automated tests** against controlled upstream responses, not production live calls. Separate local upstream and coding-agent runs check behavior that a mocked endpoint cannot prove. | Test lane | Verified evidence | Current boundary | | ---------------------------- | ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- | | OpenAI Responses | Non-streaming output, SSE completion, function call, stateless function-result follow-up, and `openai-latest` | OpenAI Responses models only | | Chat Completions | Non-streaming output, SSE completion, tool call, tool-result follow-up, and all three maintained latest aliases | The selected model must support the compatible route | | Anthropic Messages | Non-streaming output, Anthropic SSE, `tool_use`, `tool_result`, and `claude-latest` | Claude Messages models only | | Latest aliases | Endpoint gating, canonical resolution, canonical usage rows, and representative client runs | Aliases are input selectors and do not create a separate usage model | | Files in Browser Chat | File-kind detection, conversion, and model-payload assembly for images, PDFs, text, DOCX, PPTX, CSV, XLS, and XLSX | This evidence belongs to the Browser Chat workspace | | Files through the public API | No published cross-protocol pass | Capriole does not claim one universal file contract across Responses, Chat Completions, and Messages | Stream checks consume the full response and require each protocol's own terminal event. Responses ends with its completion event, Chat Completions reaches `[DONE]`, and Messages reaches `message_stop`. Tool tests send the tool result back and require the final assistant turn. Negative tests keep the protocol boundary visible. `google-latest` fails on Responses, while `openai-latest` fails on Messages. Capriole does not move either request to a different endpoint. Public API file support uses a separate release gate. Each candidate route needs the same small image, PDF, CSV, and DOCX fixtures, a content-specific answer, a streaming repeat where supported, and a record of the exact SDK, model ID, request shape, and test date. Until those live fixtures pass, the public API documentation follows the file formats supported by each native protocol rather than advertising a shared Capriole attachment field. ## Start with the client you already have If an application uses Chat Completions, follow the [Chat Completions reference](/api-reference/endpoint/chat-completions). If it is built on Responses, use the [Responses reference](/api-reference/endpoint/responses). Claude-native clients should use the [Messages reference](/api-reference/endpoint/messages). For a first request, begin with the [API quickstart](/quickstart). Python developers can follow the [OpenAI and Anthropic SDK guide](/guides/openai-anthropic-sdks). Coding-agent users can see the maintained client matrix in [One API for Coding Agents](/articles/coding-agent-compatibility). Capriole's job is to remove account and access fragmentation while respecting the protocol your client actually speaks. [Try the supported flagship models in limited free browser chat](https://capriole.ai), then upgrade when you are ready to create an API key. **Facts checked:** 2026-08-10.