# CoreValue

> CoreValue is an AI gateway with spend controls. Applications send their LLM
> requests through it; it checks budgets before each request, records its cost,
> and attributes spend to teams, customers and features.

The full text of every page is at https://docs.corevalue.dev/llms-full.txt.

- Product: Budgets, reports and settings in the console
  - [What is CoreValue?](https://docs.corevalue.dev/): Measure what each team, customer and feature costs you in AI, cap spend before it eats your margin, and prove the return.
  - [Architecture](https://docs.corevalue.dev/architecture): How a request travels through CoreValue: the ways in, the checks before the provider, how cost and budgets are kept, where data is stored and what happens when something fails.

  - **Get started**
  - [Set up your organisation](https://docs.corevalue.dev/getting-started/set-up): The steps an owner or admin takes in the console, before and after a developer connects the first application.
  - [Key concepts](https://docs.corevalue.dev/getting-started/key-concepts): The words these docs use, in plain English — read this once and the rest of the docs will make sense.

  - **Who it's for**
  - [For SaaS companies](https://docs.corevalue.dev/start-here/saas): You sell a product that calls AI models. Know what each customer costs you in AI, protect your margin, and cap a customer before they cost more than they pay.
  - [For AI-native teams](https://docs.corevalue.dev/start-here/ai-native-teams): Your teams build and work with AI every day. See which team, person and project spends what, give each a budget, and hand finance a monthly chargeback.

  - **Track cost**
  - [Overview](https://docs.corevalue.dev/features/cost-tracking/dashboard): Spend, traffic, budgets and errors for the selected range, on one page.
  - [Spend](https://docs.corevalue.dev/features/cost-tracking/spend): See where the money goes: by team, customer, feature, end user, run, key, model, provider or property.
  - [Requests](https://docs.corevalue.dev/features/cost-tracking/requests): Find, filter and inspect every request that went through CoreValue.
  - [Runs](https://docs.corevalue.dev/features/cost-tracking/runs): Follow a multi-step agent run from its first request to its last.

  - **Control spend**
  - Budgets
    - [Budgets & Limits](https://docs.corevalue.dev/features/budgets/budgets-and-limits): Cap what the gateway spends — for the whole organisation, a team, a member, a customer or a single key — and choose what happens when a cap is reached.
    - [Daily and yearly ceilings](https://docs.corevalue.dev/features/budgets/budget-windows): Cap what the organisation, a team or a key can spend in one day or one year, on a calendar in your own time zone and fiscal year.
    - [Budget alerts](https://docs.corevalue.dev/features/budgets/budget-alerts): Get an email before the organisation budget runs out, and whenever a budget is reached.
  - [Velocity limits](https://docs.corevalue.dev/features/velocity-limits): Cap how fast a proxy key, or an agent across all of its keys, can spend inside a rolling window, to stop a runaway loop in minutes instead of at the end of the month.
  - [Rate limits](https://docs.corevalue.dev/features/rate-limits): Limit how many requests the gateway accepts in a time window.
  - [Your own model prices (Preview)](https://docs.corevalue.dev/features/model-prices): Record the rates you negotiated with a provider, so requests on your own provider keys can be priced at them.
  - Access control
    - [Block models or providers](https://docs.corevalue.dev/features/access/block-models): Limit the models and providers each CoreValue key can use, and what a caller sees when a request falls outside them.
    - [Key scopes](https://docs.corevalue.dev/features/access/key-scopes): Limit a key to certain customers, models or providers, checked at the gateway before every request.
    - [Who sees whose requests](https://docs.corevalue.dev/features/access/request-visibility): Choose whether members see every request, their team's, or only their own.
    - [Access rules for tools and agents](https://docs.corevalue.dev/features/access/mcp-tool-policies): Decide who may call each MCP tool and A2A agent.
    - [Guardrails and PII masking](https://docs.corevalue.dev/features/access/guardrails): Detect, redact or refuse personal data in requests and MCP tool calls.

  - **Margins and reports**
  - [Unit economics](https://docs.corevalue.dev/features/reports/unit-economics): What one request, run or end user costs, per team, customer or feature, and whether it is moving.
  - [Customer pricing and margin](https://docs.corevalue.dev/features/reports/customer-pricing): Record what you charge each customer, see your margin on their AI spend, and get told or stop serving when it falls too low.
  - [Chargeback](https://docs.corevalue.dev/features/reports/chargeback): Split a month's AI spend by team, customer and model, close it, and hand finance a file that adds up.
  - [Executive report](https://docs.corevalue.dev/features/reports/executive): A one-page summary of AI spend and usage for leadership, ready to print or save as a PDF.
  - [Value](https://docs.corevalue.dev/features/reports/value): Weigh what AI costs against what the work is worth, using a value per unit you declare.
  - [Scheduled reports](https://docs.corevalue.dev/features/reports/scheduled): Choose who should receive a weekly summary by email or Slack.

  - **Alerts**
  - [Budget alerts](https://docs.corevalue.dev/features/budgets/budget-alerts)
  - [Slack](https://docs.corevalue.dev/features/alerts/slack): Connect a Slack workspace so CoreValue notifications can post to your channels.
  - [Webhooks](https://docs.corevalue.dev/features/alerts/webhooks): Receive every logged request, with its cost and tokens, at an HTTPS endpoint of your own, signed so you can check it came from CoreValue.

  - **Your organisation**
  - [Members](https://docs.corevalue.dev/features/organization/members): Everyone who can sign in to your organisation, their role, and how to change or remove it.
  - [Teams](https://docs.corevalue.dev/features/organization/teams): Group members and keys into teams, so spend, budgets and request visibility follow your org chart.
  - [Roles and custom roles](https://docs.corevalue.dev/features/organization/roles): Decide what each member can do, with the three built-in roles or, on Enterprise, roles you define.
  - [Invites (Preview)](https://docs.corevalue.dev/features/organization/invites): Invite a teammate to your organisation by email.
  - [Single Sign-On (OIDC)](https://docs.corevalue.dev/features/organization/single-sign-on): Send your organization's people to your own identity provider with OpenID Connect, prove your email domain, and optionally require it.
  - [API keys and virtual keys](https://docs.corevalue.dev/features/organization/api-keys): Create, edit and revoke the CoreValue keys your applications send to the gateway.
  - [Provider keys](https://docs.corevalue.dev/features/organization/provider-keys): Add the keys CoreValue uses to call OpenAI, Anthropic and the other providers on your behalf.
  - [Audit log](https://docs.corevalue.dev/features/organization/audit-log): See who changed what in your organisation, and when, and download it as CSV.
  - [Billing, plans and credits](https://docs.corevalue.dev/features/organization/billing): See your plan, change it, manage the subscription, and check your credit balance and invoices.

  - **Guides**
  - [Budget configuration](https://docs.corevalue.dev/guides/budget-configuration): Set up budgets that stop overspend without stopping your product: which layers to use, which action to pick, and how to tighten them once you have real numbers.
  - [Per-customer budgets](https://docs.corevalue.dev/guides/per-customer-budgets): Bind each request to one of your customers, gate each customer with a budget, and see what each one costs you against what they pay.
  - [Team chargeback](https://docs.corevalue.dev/guides/team-chargeback): Give each team its own keys and budget, and hand finance a monthly report of what each team spent.
- Developers: Connect your code, the API and SDKs

  - **Quickstarts**
  - [Quickstart](https://docs.corevalue.dev/getting-started/quickstart): From sign-in to a capped customer in about ten minutes: add a provider key, create a CoreValue key, send a request, see what each customer costs, and set a first budget.
  - [Use the OpenAI SDK](https://docs.corevalue.dev/getting-started/openai): Send requests through CoreValue with the OpenAI SDK you already use: change the base URL and the key, and keep your code.
  - [Use the Anthropic SDK](https://docs.corevalue.dev/getting-started/anthropic): Send Claude requests through CoreValue with Anthropic's own SDK: change the base URL and the key, and keep using the Messages API.
  - [Use the Google Gemini SDK](https://docs.corevalue.dev/getting-started/gemini): Use Google's official @google/genai SDK with Cova AI Gateway: your app sends only its Cova key, and the gateway uses the Google key stored in CoreValue.
  - [Claude Code](https://docs.corevalue.dev/getting-started/claude-code): Route Claude Code through CoreValue to see what each developer and team spends, and cap it before the month ends.

  - **Send requests**
  - [Tag your traffic](https://docs.corevalue.dev/features/cost-attribution): Tell CoreValue which of your users and customers each request was for, so you can see and cap spend per user and customer.
  - [Call other providers](https://docs.corevalue.dev/features/routing/other-providers): Groq, Mistral, DeepSeek, xAI and every other provider Cova supports — the model name to send and the base URL to use.
  - [Route by model name](https://docs.corevalue.dev/features/routing/model-routing): Send a bare model name to /v1/chat/completions and CoreValue sends it to a provider you hold a key for.
  - [Fallbacks](https://docs.corevalue.dev/features/routing/fallbacks): Try another model automatically when the first one fails.
  - [Several keys for one provider](https://docs.corevalue.dev/features/routing/key-pool): What happens when you add more than one key for the same provider.
  - [Caching](https://docs.corevalue.dev/features/routing/caching): Serve repeated requests from a cache instead of paying the provider again.
  - [Streaming](https://docs.corevalue.dev/features/routing/streaming): Stream responses through Cova, and read the request's cost when the stream ends.
  - Provider features
    - [Prompt caching](https://docs.corevalue.dev/features/routing/provider-features/prompt-caching): Cache frequently-used context across LLM providers for reduced costs and faster responses
    - [Reasoning models](https://docs.corevalue.dev/features/routing/provider-features/reasoning): Enable reasoning through a unified API on CoreValue's AI Gateway
    - [Image generation](https://docs.corevalue.dev/features/routing/provider-features/image-generation): Generate images through CoreValue's AI Gateway using models with native image output like Nano Banana Pro
    - [Context editing](https://docs.corevalue.dev/features/routing/provider-features/context-editing): Automatically manage conversation context by clearing old tool uses and thinking blocks for long-running AI agent sessions
    - [Responses API](https://docs.corevalue.dev/features/routing/provider-features/responses-api): Use the OpenAI Responses API format through CoreValue AI Gateway with your CoreValue API key

  - **MCP and agents**
  - MCP gateway
    - [How the MCP gateway works](https://docs.corevalue.dev/features/mcp/overview): Give AI tools such as Claude Code access to your MCP servers through Cova.
    - [Connect MCP clients](https://docs.corevalue.dev/features/mcp/connect-clients): Connect Claude Code, claude.ai or any MCP client to the CoreValue MCP gateway, with an API key or by signing in.
    - [Add MCP servers](https://docs.corevalue.dev/features/mcp/servers): Register the MCP servers your organisation's agents reach through CoreValue, limit their tools, and switch them on and off.
    - [Servers that need their own sign-in](https://docs.corevalue.dev/features/mcp/upstream-sign-in): Connect MCP servers that use an API key or OAuth, including servers where each member signs in with their own account.
    - [Tool-call logging and cost](https://docs.corevalue.dev/features/mcp/tool-calls): See every MCP tool call your agents make through CoreValue: which server and tool, which key, what policy decided, and how it went.
    - [Try tools in the playground](https://docs.corevalue.dev/features/mcp/playground): Chat with a model that calls your MCP tools through the gateway, from the console, before you connect a client.
  - Agent gateway
    - [How the agent gateway works](https://docs.corevalue.dev/features/agents/overview): Call other AI agents over the A2A protocol through CoreValue.
    - [Register an agent](https://docs.corevalue.dev/features/agents/register): Add an agent your applications can call.
    - [Call an agent](https://docs.corevalue.dev/features/agents/call): Send a request to a registered agent.

  - **SDKs and integrations**
  - [Cova SDK (TypeScript and Python)](https://docs.corevalue.dev/sdks/cova-sdk): Get started with the @cova/gateway SDK for per-call FinOps metadata
  - [Claude Agent SDK](https://docs.corevalue.dev/sdks/mcp-package): Use CoreValue AI Gateway with the Claude Agent SDK for building AI agents with automatic observability
  - Integrations
    - [All integrations](https://docs.corevalue.dev/sdks/integrations/overview): Integrate CoreValue AI Gateway with popular frameworks and tools to access LLM providers with top tier observability
    - [OpenAI Codex](https://docs.corevalue.dev/sdks/integrations/codex): Use OpenAI Codex CLI and SDK with CoreValue AI Gateway to log your coding agent interactions.
    - [DSPy](https://docs.corevalue.dev/sdks/integrations/dpsy): Integrate CoreValue AI Gateway with DSPy to access LLM providers with unified observability and optimization.
    - [LangChain](https://docs.corevalue.dev/sdks/integrations/langchain): Integrate CoreValue AI Gateway with LangChain to access LLM providers with unified observability.
    - [Langfuse](https://docs.corevalue.dev/sdks/integrations/langfuse): Integrate CoreValue AI Gateway with Langfuse to access LLM providers with observability and LLM tracing.
    - [LangGraph](https://docs.corevalue.dev/sdks/integrations/langgraph): Integrate CoreValue AI Gateway with LangGraph to build multi-agent workflows with access to LLM providers.
    - [LiteLLM](https://docs.corevalue.dev/sdks/integrations/litellm): Use Cova AI Gateway with LiteLLM to get top tier observability for your LLM requests.
    - [LlamaIndex](https://docs.corevalue.dev/sdks/integrations/llamaindex): Use the CoreValue LLM for LlamaIndex to route OpenAI-compatible requests through the CoreValue AI Gateway with full observability.
    - [n8n](https://docs.corevalue.dev/sdks/integrations/n8n): Use the CoreValue Chat Model node in n8n workflows to route LLM requests through the AI Gateway with full observability.
    - [OpenAI Agents](https://docs.corevalue.dev/sdks/integrations/openai-agents): Integrate CoreValue AI Gateway with OpenAI Agents SDK to build AI agents with tools and full observability.
    - [Semantic Kernel](https://docs.corevalue.dev/sdks/integrations/semantic-kernel): Integrate CoreValue AI Gateway with Microsoft Semantic Kernel to access LLM providers with unified observability.
    - [Vercel AI SDK](https://docs.corevalue.dev/sdks/integrations/vercel-ai-sdk): Send Vercel AI SDK calls through the CoreValue gateway, attribute their cost to customers and features, and route through Vercel AI Gateway.
    - [Xcode](https://docs.corevalue.dev/sdks/integrations/xcode): Configure Xcode's Intelligence model provider to route through CoreValue's AI Gateway for observability.
    - [Zapier](https://docs.corevalue.dev/sdks/integrations/zapier): Use the CoreValue Zapier app to run Chat Completions via the AI Gateway — no provider keys required.

  - **Reference**
  - [Authentication](https://docs.corevalue.dev/api-reference/authentication): How to send your Cova key with each request.
  - [Headers](https://docs.corevalue.dev/api-reference/headers): Every Cova-* header you can send, and every one Cova sends back.
  - [Response headers](https://docs.corevalue.dev/api-reference/response-headers): The Cova-* headers CoreValue adds to a response, when each one is present, and the final cova frame on a stream.
  - [Errors](https://docs.corevalue.dev/api-reference/errors): The errors Cova returns, what each one means, and what to do about it.
  - [List models](https://docs.corevalue.dev/api-reference/list-models): GET /v1/models — the models your organisation can call.
  - [Look up a request's cost](https://docs.corevalue.dev/api-reference/request-cost-lookup): GET /gateway/v1/meta/{requestId} — the cost and details of a request after it finished.

  - **Guides**
  - [Keep AI working when a provider fails](https://docs.corevalue.dev/guides/provider-failover): Retries, fallback models, fallback to another provider, and downgrading instead of refusing: what CoreValue does on its own and what you set up.
  - [Use with AI coding assistants](https://docs.corevalue.dev/guides/ai-coding-assistants): Give Claude Code, Cursor, GitHub Copilot and other assistants the facts they need to write CoreValue integrations correctly.
  - [Migrate from Helicone](https://docs.corevalue.dev/guides/migrate-from-helicone): Move your Helicone traffic to CoreValue: change the base URL and key, rename your Helicone-* headers to Cova-*, and get budgets that stop spend instead of reporting it.