Skip to main content

Bring Your Own Keys (BYOK)

Bring Your Own Keys (BYOK) allows you to connect your own API keys from providers like OpenAI, Anthropic, Google, and others to Adaptive. This gives you maximum cost savings while still benefiting from Adaptive’s intelligent routing, caching, and reliability features.

How BYOK Works

When you provide your own provider API keys, Adaptive uses them to make requests on your behalf instead of using our pooled API keys. This means:

Pay Only Overhead

You only pay Adaptive’s overhead fee, not the underlying model costs. Your provider bills you directly for the model usage.

Full Routing Control

Continue to benefit from intelligent routing, semantic caching, fallback mechanisms, and all other Adaptive features.

Enhanced Privacy

Your API requests go through your own provider accounts, giving you complete control and isolation.

Usage Tracking

Track usage across both Adaptive’s dashboard and your provider dashboards for comprehensive visibility.

Pricing with BYOK

Overhead-Only Pricing

When using your own API keys, you only pay Adaptive’s overhead:
  • Input tokens: $0.10 per 1M tokens
  • Output tokens: $0.20 per 1M tokens
  • Semantic cache hits: 50% off (half the normal overhead)
  • Prompt cache hits: Free
You do NOT pay Adaptive for the underlying model costs - those are billed directly by your provider (OpenAI, Anthropic, Google, etc.).

Cost Example

Let’s say you make a request that uses:
  • 100,000 input tokens
  • 50,000 output tokens
Without BYOK (using Adaptive’s provider keys):
  • Provider model cost (e.g., GPT-4): ~1.25(input)+ 1.25 (input) + ~3.75 (output) = $5.00
  • Adaptive overhead: 0.01(input)+0.01 (input) + 0.01 (output) = $0.02
  • Total charged by Adaptive: $5.02
With BYOK (using your own OpenAI key):
  • Provider model cost: ~$5.00 (billed directly by OpenAI to you)
  • Adaptive overhead: 0.01(input)+0.01 (input) + 0.01 (output) = $0.02
  • Total charged by Adaptive: $0.02
  • Total charged by OpenAI: $5.00

Benefits of BYOK

Maximum Cost Savings

By paying only the overhead fee to Adaptive, you can save significantly on high-volume workloads. This is especially valuable for:
  • High-traffic production applications
  • Large-scale batch processing
  • Development and testing environments
  • Cost-sensitive projects

Complete Control

When you use your own keys:
  • Billing control: Direct relationship with providers for billing and invoicing
  • Usage limits: Set your own rate limits and spending caps at the provider level
  • Account isolation: Separate environments for dev, staging, and production
  • Compliance: Meet specific compliance requirements that require direct provider relationships

Privacy and Data Governance

  • Your requests are authenticated with your own credentials
  • No request pooling with other Adaptive users
  • Direct audit trail with your provider
  • Easier compliance with data residency requirements

Setting Up BYOK

1

Get Provider API Keys

Obtain API keys from the providers you want to use:
2

Add Keys to Adaptive

In your Adaptive dashboard:
  1. Navigate to your project settings
  2. Go to “Custom API Keys” or “Provider Configurations”
  3. Add your provider API keys securely
  4. Keys are encrypted and stored securely
3

Enable BYOK for Project

Configure your project to use custom keys:
  • Set priority for which providers to use
  • Configure fallback behavior
  • Test the configuration with sample requests
4

Monitor Usage

Track your usage across both:
  • Adaptive dashboard (overhead costs, routing decisions)
  • Provider dashboards (model costs, quotas)

Supported Providers

BYOK is currently supported for:

OpenAI

GPT-4, GPT-3.5, and all OpenAI models

Anthropic

Claude Opus, Sonnet, and Haiku

Google

Gemini Pro, Flash, and other models

Groq

All Groq-hosted models

DeepSeek

DeepSeek models and variants

More Coming

Additional providers being added regularly

Security and Best Practices

Key Security

Never share your API keys or commit them to version control. Adaptive stores your keys encrypted at rest and in transit.
Best practices:
  • Rotate keys regularly
  • Use separate keys for dev/staging/production
  • Monitor key usage in both Adaptive and provider dashboards
  • Set spending limits at the provider level
  • Revoke unused or compromised keys immediately

Monitoring and Alerts

Set up monitoring for:
  • Unexpected usage spikes
  • Provider quota exhaustion
  • Failed authentication attempts
  • Cost threshold alerts

Routing with Custom Keys

Even with BYOK enabled, Adaptive’s intelligent routing continues to work:
  1. Model Selection: Adaptive analyzes your request complexity
  2. Provider Selection: Routes to the optimal provider based on:
    • Your available custom keys
    • Model capabilities and performance
    • Current provider availability
    • Cost optimization
  3. Fallback: If your custom key fails or hits quota, Adaptive can:
    • Fall back to other custom keys you’ve configured
    • Fall back to Adaptive’s pooled keys (at standard pricing)
    • Return graceful errors based on your configuration

Frequently Asked Questions

No, you can mix and match. Use custom keys for some providers and let Adaptive use its pooled keys for others. Adaptive will route intelligently based on what’s available and most cost-effective.
Adaptive can automatically fall back to other configured keys or its own pooled keys, depending on your fallback configuration. You can also configure strict mode to fail the request instead.
Yes, Adaptive’s dashboard shows detailed request logs including which provider and which key (yours vs pooled) was used for each request.
BYOK is available on Team and Enterprise plans. Developer plan users can upgrade to access this feature.

Getting Started

Ready to set up BYOK?

Configure Custom API Keys

Go to your project settings to add your provider API keys and start saving on overhead costs

Need Help?