Your keys, your economics
Attach your own provider API keys so requests run on your accounts-keeping your billing, rate limits, and negotiated discounts instead of FastRouter's managed key pools.
Bring Your Own Key
Route through your own provider keys
Attach your own provider API keys and route traffic through your own accounts. Keep your provider billing, rate limits, and discounts-while gaining FastRouter's routing, failover, governance, and observability.
No credit card required · Free to start
External keys
Provider integrations
Routing through your own provider accounts
- Active
OpenAI
openai-prod
API keyAll Projects - Active
Anthropic
anthropic-prod
API keyProduction - Active
Google AI Studio
google-research
API keyResearch
Why BYOK
Bring your keys without losing the gateway
External Keys route requests through your own provider accounts while FastRouter keeps layering routing, governance, and observability on top.
Encrypted and owner-controlled
Credentials are encrypted at rest and never returned in API responses after saving, and only Organization Owners can create, modify, or delete them.
One integration, used everywhere
Give each integration a Provider Slug and reference it from Virtual Models, gateway configs, and the Activity Log across your projects-no application rewrites.
How it works
From your app to your provider, through your key
FastRouter sits in front of your provider account: it injects your encrypted credentials, applies routing and governance, then forwards each request to the provider on your own key.
Your app
One API call
- Requests a model or virtual model alias.
FastRouter
The gateway
- Applies routing, failover, and governance.
- Injects your encrypted provider key.
Your key
BYOK integration
- Encrypted credential, scoped to the project.
Provider
Your account
- Runs on your billing, limits, and discounts.
Your provider relationship, unchanged
FastRouter never moves your traffic onto its own billing. Your keys, quotas, and provider contracts keep applying-the gateway only adds routing, governance, and observability around them.
- Costs and rate limits stay governed by your provider account, not shared key pools.
- Every request is tagged with the integration's Provider Slug in the Activity Log.
Activity Log
- claude-opus-4.8anthropic-prod
- gpt-5.5openai-prod
- gemini-3-progoogle-research
Add an integration
Connect a provider in a three-step wizard
From Setup → External Keys, New Integration pairs a provider with your credentials and a model selection. Each integration is a named, project-scoped record you can spin up in minutes.
Pick from supported providers
Connect OpenAI, Anthropic, Google, Groq, Together, and more-most with an API key, plus Service Account or Azure config where the provider requires it.
Name, slug, and project scope
Give each integration a display name, a unique Provider Slug, and scope it to All Projects or specific projects.
Advanced routing options
Optionally set a Custom Host with an OpenAI-, Anthropic-, or Cohere-compatible API format and forward custom auth headers.
New integration
Step 2 of 3
Anthropic Claude
Selected provider
Name
Anthropic Production
Provider slug
anthropic-prod
API key
sk-ant-••••••3f9
Project scope
Production
Advanced — custom host & API formatOptional
Encrypted credentials
Credentials encrypted and owner-controlled
Your provider secrets stay protected end to end. They are encrypted at rest, never echoed back after saving, and changeable only by the people you trust.
Encrypted at rest
Provider API keys and service-account JSON are stored encrypted and never returned in API responses once saved.
Owner-only changes
Only Organization Owners create, modify, or delete credentials; Project Admins and Developers use them in scope but can't edit them.
Your account governs usage
Costs and rate limits are governed by your provider account, not FastRouter's shared key pools.
Stored credential
Provider
Anthropic
Credential
sk-ant-••••••••••
Managed by
Owners only
Costs & rate limits
Your provider account
Encrypted at rest and never returned in API responses after saving.
Provision & reference
Provision models, then route by slug
Choose which models each integration exposes, add your own custom models, and reference the integration anywhere by its Provider Slug.
Catalog and custom models
Toggle FastRouter catalog models on or off, or use Add Custom Model to register fine-tuned and privately hosted models with their own slug and pricing.
Use it across the platform
Reference the Provider Slug in Virtual Models and in Gateway Configs for fallback and load-balancing routing.
Per-request traceability
Every request shows the integration's Provider Slug in the Activity Log, so you always know which credential was used.
Model provisioning
All·None
- Enabled
claude-opus-4.8
Catalog model
- Enabled
claude-sonnet-4.6
Catalog model
- Off
claude-haiku-4
Catalog model
- Add custom model
Referenced by sluganthropic-prod
BYOK vs managed
Keep your provider economics, gain the gateway
With BYOK, requests run on your provider account instead of FastRouter's managed key pools-while every gateway capability stays available either way.
| Capability | BYOKYour provider keys | FastRouter creditsManaged key pools |
|---|---|---|
| Provider account & economics | ||
| Billing source | Your provider account | FastRouter credits |
| Rate limits governed by | Your provider account | FastRouter key pools |
| Keep negotiated provider discounts | Included | Not included |
| Supply your own provider credentials | Included | Not included |
| FastRouter gateway | ||
| Routing & instant failover | Included | Included |
| Governance & access controls | Included | Included |
| Logs, traces & observability | Included | Included |
| Project-scoped configuration | Included | Included |
Both paths run through the FastRouter gateway-BYOK simply routes requests through your own provider accounts instead of FastRouter's managed key pools.
Use cases
Built for teams with provider accounts
Keep the provider relationships you already have-contracts, quotas, and compliance-while routing everything through one gateway.
Keep your negotiated provider pricing
Route through accounts that already have committed pricing and discounts so your existing provider economics keep applying through FastRouter.
Run on your own rate limits
Lean on your provider account's quotas instead of shared pools for predictable production throughput.
Separate production and research
Run multiple integrations for the same provider-each scoped to different projects, like Anthropic Production and Anthropic Research.
Power virtual models and failover
Reference integrations by Provider Slug in Virtual Models and Gateway Configs to build aliases, fallbacks, and load-balancing.
FAQ
BYOK questions, answered
BYOK lets Organization Owners attach API credentials from supported LLM providers to their organization. Traffic routes through your own provider account-preserving your negotiated pricing, rate limits, and compliance posture-while you still gain FastRouter's routing, failover, governance, and observability. Each integration is a named, project-scoped record that pairs a provider with credentials and a model selection.
You can connect OpenAI, Anthropic Claude, Google AI Studio, Google Vertex AI, Microsoft Azure, Groq, Together AI, Fireworks AI, DeepInfra, Baseten, Nebius, Perplexity AI, Moonshot, Minimax, X-AI, FAL AI, and Pollo AI. Most providers use an API key; Google Vertex AI uses a Service Account JSON file, and Microsoft Azure requires a resource name and deployment configuration.
Credentials are encrypted at rest and are never returned in API responses after they are saved. Only Organization Owners can create, modify, or delete them, while Project Admins and Developers can use integrations within their project scope but cannot change the credentials.
Because requests use your own provider keys, costs and rate limits are governed by your provider account-not FastRouter's shared key pools. You keep your provider billing, quotas, and any negotiated discounts while routing through the gateway.
Each integration has a unique Provider Slug. Reference it in Virtual Models to alias a model to a specific integration, in Gateway Configs for fallback and load-balancing, and find it in the Activity Log, which shows the Provider Slug used on every request.
Yes. Within an integration you can toggle FastRouter catalog models on or off, and use Add Custom Model to register fine-tuned or privately hosted models with their own model slug, an optional base model, a custom host, and pricing for cost tracking. Only models in the FastRouter catalog plus your custom models are routable.
Bring your own keys in minutes
Connect your first provider, scope it to a project, and start routing through your own account with full governance and observability.