DEV Community

Pranay Batta
Pranay Batta

Posted on

Your Claude Code Bill is Growing, here's How to Control It

#ai #llm #productivity #opensource

TL;DR: Claude Code usage scales linearly with your team size but the costs don't stay linear. An unmonitored team of 20 developers can burn through lakhs per month in API costs without anyone noticing until the invoice arrives. Bifrost (open-source, Go, 11µs overhead) gives you per-developer budgets via virtual keys, real-time cost tracking, model routing to cheaper alternatives for simple tasks, and automatic failover; all without developers changing a single line of code. GitHub | Docs | Website

The Cost Problem Nobody Budgets For

Look, here's the thing. Claude Code is genuinely transformative for developer productivity. No argument there.

But here's what happens when a team of 20 developers starts using it daily:

No visibility. You have no idea who's spending what. Developer A might be running Claude Code on a massive monorepo refactor (₹15,000/day). Developer B might be using it for variable renaming (₹500/day). Both show up as one line item on the Anthropic invoice.

No caps. There's no built-in mechanism to set a ₹25,000/month limit per developer. One recursive loop, one overzealous autonomous session, one weekend experiment; and you've blown through next quarter's budget.

No routing intelligence. Every Claude Code request hits Opus-tier pricing by default. But maybe 60% of tasks; renaming variables, writing boilerplate, simple completions could be handled by a cheaper model at identical quality.

No failover. When Anthropic rate-limits you (and they will, at scale), Claude Code just... stops working. No automatic fallback to Bedrock or another provider.

We hit all of these problems running Bifrost. So we built the solution into the gateway itself.

How Virtual Keys Solve This

Bifrost's virtual key system gives every developer (or team, or project) their own API key with independent controls. One gateway, many keys, each with its own rules.

Here's what a virtual key gives you:

Per-Developer Budget Caps 

Developer A: Virtual Key "dev-pranay"
  → Monthly budget: ₹25,000
  → Rate limit: 100 requests/minute
  → Models allowed: claude-sonnet-4-20250514, claude-haiku-4-5-20251001

Developer B: Virtual Key "dev-intern"
  → Monthly budget: ₹5,000
  → Rate limit: 30 requests/minute
  → Models allowed: claude-haiku-4-5-20251001 only
Enter fullscreen mode Exit fullscreen mode

When a developer hits their budget cap, Bifrost returns a clear error. No surprise invoices. No "who spent ₹2 lakh last month?" meetings.

Four-Tier Budget Hierarchy

This is the piece that makes it work at org scale. Bifrost enforces budgets at four levels:

  1. Customer — total org-wide spend cap
  2. Team — per-team allocation (frontend, backend, ML, etc.)
  3. Virtual Key — per-developer or per-project cap
  4. Provider Config — per-provider spend limit

Each level is enforced independently. A developer can't exceed their virtual key budget even if the team still has headroom. The team can't exceed its allocation even if the org budget has room. Defence in depth.

Setting This Up (10 Minutes)

Step 1: Get Bifrost Running 

npx -y @maximhq/bifrost
# Open http://localhost:8080
Enter fullscreen mode Exit fullscreen mode

Step 2: Add Your Providers

In the Web UI, add your Anthropic API key (and optionally OpenAI, Bedrock, etc. for failover).

Step 3: Create Virtual Keys

For each developer, create a virtual key with:

  • Monthly or daily budget cap
  • Rate limits (requests per minute)
  • Allowed model list
  • Fallback chain (e.g., try Anthropic → fall back to Bedrock)

Step 4: Point Claude Code at Bifrost

Each developer sets one environment variable:

# In .bashrc, .zshrc, or Claude Code config
export ANTHROPIC_BASE_URL=http://your-bifrost:8080/anthropic
export ANTHROPIC_API_KEY=vk-dev-pranay  # Their virtual key
Enter fullscreen mode Exit fullscreen mode

That's it. Claude Code doesn't know the difference. It thinks it's talking to Anthropic. But every request flows through Bifrost, gets logged, gets budget-checked, and gets routed according to your rules.

Real-Time Cost Tracking

Every request through Bifrost gets logged with:

  • Cost — input tokens, output tokens, total cost in your currency
  • Model used — which model actually handled the request
  • Latency — time to first token, total response time
  • Developer — which virtual key made the request
  • Timestamp — when the request happened

The Web UI at http://localhost:8080 shows this in real time. Filter by virtual key, by model, by time range. Export for your finance team.

No more waiting for the monthly Anthropic invoice to find out what happened. You know exactly who spent what, on which model, for which type of task as it happens.

Model Routing: Stop Paying Opus Prices for Haiku Tasks

Here's where the savings get interesting.

Bifrost supports weighted routing; you can configure virtual keys to route a percentage of traffic to different models based on your rules.

For Claude Code, the practical approach:

  • Complex tasks (architecture decisions, large refactors, debugging): Route to Claude Sonnet/Opus
  • Simple tasks (boilerplate, renaming, formatting): Route to Claude Haiku or GPT-4o-mini

You configure this per virtual key. The developer doesn't change anything. Bifrost handles the routing, format translation, and response normalisation.

The math is straightforward:

Model Cost per 1M input tokens
Claude Opus ~$15
Claude Sonnet ~$3
Claude Haiku ~$0.78
GPT-4o-mini ~$0.15

If 60% of your Claude Code tasks are simple enough for Haiku, routing those saves ~75% on that traffic. Combined with semantic caching (which Bifrost also supports), overall cost reduction of 50-70% is realistic for most teams.

Automatic Failover

When Anthropic rate-limits your team (429 errors), Bifrost automatically fails over to the next provider in the chain. If you've configured Bedrock as a fallback:

Primary: Anthropic Claude Sonnet
  ↓ (rate limited)
Fallback: AWS Bedrock Claude Sonnet
  ↓ (if also unavailable)
Fallback: OpenAI GPT-4o
Enter fullscreen mode Exit fullscreen mode

Each fallback is a fresh request; all plugins (caching, governance, logging) re-execute. The developer's Claude Code session doesn't break. They might not even notice the failover happened.

What This Looks Like at Scale

A team of 50 developers using Claude Code daily:

Without Bifrost:

  • No per-developer visibility
  • Monthly Anthropic bill: ₹15-25 lakh (highly variable)
  • Zero cost control beyond "please use less"
  • Downtime during rate limiting

With Bifrost:

  • Per-developer budget caps and real-time tracking
  • Monthly cost: ₹5-10 lakh (controlled routing + caching)
  • Automatic failover during rate limiting
  • Finance team gets weekly cost reports by team
  • 11µs gateway overhead; developers don't notice it

Get Started 

npx -y @maximhq/bifrost
# Open http://localhost:8080
# Add providers → Create virtual keys → Distribute to developers
Enter fullscreen mode Exit fullscreen mode

GitHub: git.new/bifrost | Docs: getmax.im/bifrostdocs | Website: getmax.im/bifrost-home

The gateway adds 11µs of overhead. The budget controls save lakhs per month. Whether that trade-off makes sense; well, the math speaks for itself.

Top comments (0)