Tracking Costs Across OpenAI, Anthropic & Azure

Most AI agencies start with one LLM provider. You pick OpenAI because it's the default, or Anthropic because Claude is better for your use case, and that's what you use.

Then things get complicated.

A client needs Azure OpenAI for compliance reasons. Another wants Claude for complex reasoning tasks. A third has an existing OpenAI contract you need to work within. Suddenly you're managing multiple providers, multiple pricing models, and multiple billing dashboards.

Getting a single view of costs across all of them is harder than it should be.

Why multi-provider is increasingly common

There are legitimate reasons to use multiple LLM providers:

Different strengths. GPT-4o is great for general tasks. Claude excels at long-context reasoning. Having both lets you pick the right tool for each job.

Client requirements. Enterprise clients often require Azure for data residency or compliance. You don't get to choose—you adapt.

Cost optimization. gpt-4o-mini is much cheaper than gpt-4o for simpler tasks. Anthropic's Haiku is cheap for classification. Mixing models saves money.

Redundancy. When one provider has an outage, having another as backup keeps things running.

The downside is administrative complexity. Each provider has its own dashboard, its own pricing model, and its own way of reporting usage.

The pricing puzzle

LLM pricing is straightforward for a single provider. It gets confusing when you compare across providers:

Model	Input (per 1M tokens)	Output (per 1M tokens)
gpt-4o	$2.50	$10.00
gpt-4o-mini	$0.15	$0.60
claude-3-5-sonnet	$3.00	$15.00
claude-3-5-haiku	$0.25	$1.25

These prices change. They have different tiers, different billing cycles, and different ways of counting tokens.

Azure adds another layer: you're billed for provisioned throughput or pay-as-you-go, depending on your setup. The pricing maps to OpenAI's but with Azure's enterprise billing structure.

Answering "what did we spend on LLMs this month?" requires logging into multiple dashboards and doing arithmetic.

The attribution challenge

Costs are one thing. Attribution is another.

Even if you know total spend, you probably don't know:

• How much did Client A's projects cost vs. Client B's?
• Which workflows are the biggest cost drivers?
• Is one particular prompt eating the budget?

Without attribution, you can't:

• Price projects accurately
• Identify cost optimization opportunities
• Bill clients for actual usage (if that's your model)

This is especially hard with n8n workflows. The workflow calls an LLM, but n8n doesn't track token usage. You know the workflow ran, but not how much it cost.

Approaches to unified tracking

The spreadsheet method

Low-tech but effective for small scale:

1. Monthly, log into each provider dashboard
2. Export usage data to a spreadsheet
3. Manually attribute to clients based on which projects use which APIs
4. Sum and report

This works for 3-4 clients and 1-2 providers. Beyond that, it's error-prone and tedious.

Per-client API keys

Create separate API keys (or accounts) for each client:

• OpenAI: Separate API keys per project
• Anthropic: Separate workspaces
• Azure: Separate resource groups

Now each client's usage is isolated. You can pull their costs directly.

Downsides:
- Key management becomes complex
- You might miss volume discounts by fragmenting usage
- Not all providers support fine-grained separation

Application-level logging

If you control the code, log every LLM call:

async function callLLM(prompt, clientId, workflowId) {
  const response = await openai.chat.completions.create({...});

  await logUsage({
    clientId,
    workflowId,
    provider: 'openai',
    model: response.model,
    promptTokens: response.usage.prompt_tokens,
    completionTokens: response.usage.completion_tokens,
    estimatedCost: calculateCost(response)
  });

  return response;
}

This gives you detailed attribution but requires:
- Code changes in every project
- A place to store and query the logs
- Maintenance as pricing changes

Centralized monitoring tools

The cleanest solution: a dedicated tool that pulls from multiple providers and unifies the data.

Ideally it would:
- Connect to OpenAI, Anthropic, and Azure billing
- Map usage to your client/workflow structure
- Present costs in a single dashboard
- Handle pricing updates automatically

This is something we're building into Administrate.dev. The workflow monitoring is already there—adding LLM cost tracking to the same dashboard is the natural extension.

Practical cost optimization

Once you can see costs clearly, you can optimize them:

Model selection. Not every task needs the most expensive model. Classification, summarization, and simple extraction often work fine with cheaper options. Route tasks to appropriate models.

Prompt efficiency. Shorter prompts cost less. Review your prompts for unnecessary verbosity. System prompts that repeat with every call are especially worth trimming.

Caching. If you're making the same call repeatedly (same prompt, same inputs), cache the result. This is especially relevant for reference data lookups.

Batching. Some providers offer discounts for batch processing. If your use case allows delayed responses, batching can cut costs significantly.

Provider arbitrage. For equivalent tasks, use the cheaper provider. Haiku for simple classification, Sonnet for complex reasoning.

Building your tracking system

If you're managing multi-provider LLM costs manually today, here's how to improve:

Short term (this week):
- Pull current month's usage from each provider
- Create a simple spreadsheet tracking total costs by provider and month
- Estimate attribution to clients based on project knowledge

Medium term (this month):
- Evaluate per-client API key separation for your highest-volume clients
- Set up calendar reminders for monthly cost reviews
- Document which workflows use which models/providers

Long term (this quarter):
- Implement systematic logging or evaluate monitoring tools
- Build attribution into your project setup process
- Create client-facing cost reports

The goal is visibility. Once you can see what you're spending and where, optimization opportunities become obvious.

The multi-provider future

LLM providers are multiplying, not consolidating. New models, new pricing tiers, new capabilities appear constantly.

The agencies that thrive will be the ones that can:
- Quickly adopt new providers when they offer advantages
- Track costs accurately across a diverse stack
- Make data-driven model selection decisions

Treating multi-provider as a solvable operational problem—rather than an inevitable mess—is a competitive advantage. Start building the visibility now, and you'll be ready for whatever the LLM landscape throws at you next.