"So... how much is this going to cost me each month?"

It's the question every client asks. And if you're building AI solutions, it's the question that makes you pause just a little too long.

Because the honest answer is: "It depends."

It depends on how many customers message their chatbot. It depends on how long those conversations get. It depends on whether they're asking simple questions or demanding detailed explanations. It depends on which model you're using, how many tokens each request burns, and whether OpenAI decides to change their pricing next Tuesday.

Try explaining that to a client who just wants a number for their budget spreadsheet.

So you do what most of us do: you guess. You pick a number that feels right, hope usage stays reasonable, and quietly eat the difference when it doesn't.

That's not a pricing strategy. That's gambling.

The Three Roads to Headaches

Before we talk about what works, let's acknowledge the options that don't. If you've been building AI solutions for clients, you've probably tried at least one of these.

Option 1: Share Your API Key

The path of least resistance. You have an OpenAI account. The client needs AI. Just use your key and figure out the money later.

Here's what happens next:

You have no idea which client is responsible for which costs. Your monthly bill is one big number with no breakdown. That chatbot you built for Client A? It might be burning through tokens like crazy—or maybe it's Client B's internal tool that's gone haywire. You won't know until you're staring at a bill that's three times what you expected.

And when that happens, good luck having the conversation where you explain why their "simple AI feature" suddenly costs $400 this month when it was $80 last month.

Worse: you have no way to stop it. If a client's usage spikes—intentionally or not—your credit card gets charged. You're essentially giving every client a blank check drawn on your account.

Option 2: Make Clients Get Their Own Keys

The opposite extreme. Let them deal with OpenAI directly. You build the solution, they provide the API key, everyone's responsible for their own costs.

Sounds clean in theory. In practice:

You've just created a support nightmare. Clients will ask you why their key isn't working (they hit their limit). They'll ask you to explain their OpenAI bill (good luck). They'll want to know why costs are higher this month (because their customers are actually using the thing you built).

You've also lost all control over the client experience. If they set a low spending limit and it gets hit mid-day, your solution just... stops working. They blame you. You point at OpenAI. Everyone's frustrated.

And here's the business problem: the client now sees the raw API costs. That chatbot that costs them $50/month in API fees? They start wondering why they're paying you $200/month to "manage" it. The value you provide becomes invisible because all they see is the OpenAI line item.

Option 3: Invoice Manually with Markups

The spreadsheet approach. You track usage somehow, calculate costs, add your markup, and send an invoice.

This works right up until you have more than three clients.

Now you're spending hours each month pulling usage data, cross-referencing API costs, calculating markups, generating invoices, and answering questions when clients dispute the numbers.

You've become an accountant. A really inefficient one, using spreadsheets and manual processes that would make an actual accountant cringe.

And the invoicing lag creates its own problems. By the time a client sees that their bill doubled, it's already happened. There's no real-time visibility, no alerts, no way to course-correct before costs spiral.

What You Actually Need

Let's step back. What would a real solution look like?

Isolation: Each client gets their own API key. Their usage is tracked separately. Their costs are their costs.

Control: You set the rules. Spending limits, usage caps, model access—whatever boundaries make sense for each client relationship.

Pricing flexibility: Different clients need different arrangements. Some want predictability. Some want transparency. Some want the cheapest option. You need to accommodate all of them without building a custom billing system for each.

Visibility: Real-time dashboards showing what's happening. No more end-of-month surprises. No more guessing which client is responsible for that cost spike.

Automation: The billing math happens automatically. You set the pricing model once, and the system calculates what each client owes based on their actual usage.

This isn't a fantasy. It's table stakes for running AI solutions professionally. The question is: how do you get there?

The Three Pricing Models That Actually Work

After watching agencies struggle with AI pricing (and struggling with it ourselves), we've landed on three models that cover virtually every client scenario. Each has its place. The key is matching the right model to the right client.

Model 1: Percentage Margin

How it works: You take the actual API cost and add a percentage markup.

If your client's usage costs $100 and you've set a 25% margin, they pay $125. You keep $25.

Actual API Cost	Your Margin	Client Pays	Your Profit
$50	25%	$62.50	$12.50
$100	25%	$125	$25
$200	25%	$250	$50
$500	25%	$625	$125

When to use it: This is your default for clients with unpredictable or highly variable usage.

Think about a marketing agency using your AI writing assistant. Some months they're cranking out content for a product launch—50 blog posts, 200 social captions, endless revisions. Other months they're in strategy mode and barely touch it.

With percentage margin pricing, the math just works. Busy month? They pay more, but you also earn more. Quiet month? Lower bill, but you still make your margin. The relationship stays fair regardless of volume.

It's also the safest model for you. You literally cannot lose money on API costs. Every dollar that goes to OpenAI comes with your cut attached.

The tradeoff: Your client's bill varies month to month. Some clients hate this. They want a number they can put in a budget and forget about. If predictability matters more to them than paying for exactly what they use, this isn't the right model.

Real-world example:

"We'll set you up with our AI research assistant. You pay actual API costs plus 30% for management and support. Based on your team size, I'd estimate $150-300/month, but it'll flex with how much you use it. You'll have a dashboard showing real-time costs so there are never surprises."

This works because you're being transparent about the model, setting expectations with a range, and giving them visibility. Clients who value fairness over predictability will appreciate this approach.

Model 2: Fixed Fee

How it works: You pass through the actual API costs and add a flat dollar amount on top.

If your client's usage costs $100 and you charge a $75 fixed fee, they pay $175. You keep $75.

Actual API Cost	Your Fee	Client Pays	Your Profit
$50	$75	$125	$75
$100	$75	$175	$75
$200	$75	$275	$75
$500	$75	$575	$75

When to use it: This is for clients who want full transparency into what AI actually costs, but understand that your services have value beyond the API calls.

Some clients—especially larger companies or those with procurement departments—want to see the real numbers. They're not trying to cut you out; they just need to understand where the money goes. Maybe it's for internal reporting. Maybe it's for compliance. Maybe they're just the type who reads every line item on every invoice.

The fixed fee model lets you show them exactly what OpenAI charges, with your management fee clearly separated. It builds trust because there's nothing hidden.

The tradeoff: Your profit doesn't scale with their usage. If a client's API costs jump from $100 to $500, you still make the same $75. On high-volume months, you might wish you'd gone with percentage margin.

But here's the flip side: on low-volume months, you still make your $75. The fee is guaranteed income that covers your operational overhead regardless of how much (or little) the client uses the system.

Real-world example:

"Here's how the pricing works: you pay the actual API costs—what OpenAI charges us—plus a $100/month platform fee that covers monitoring, support, and maintenance. Last month, similar usage patterns ran about $80 in API costs, so you'd be looking at around $180 total. You'll get an itemized breakdown every month showing exactly what went where."

This works for clients who appreciate transparency and want to understand what they're paying for. The separation of "AI costs" and "your services" actually helps them see your value more clearly.

Model 3: Fixed Price

How it works: You charge a flat monthly rate regardless of actual usage.

If you set the price at $299/month, the client pays $299/month whether their actual API costs are $50 or $200.

Actual API Cost	Monthly Price	Client Pays	Your Profit
$50	$299	$299	$249
$100	$299	$299	$199
$200	$299	$299	$99
$150	$299	$299	$149

When to use it: This is the subscription model. It's for clients who want one number, no variability, no thinking required.

Small business owners love this. They don't want to understand tokens or API pricing or usage tiers. They want to know: "What do I pay each month?" Give them a number, and they're happy.

This model also has the highest perceived value. A "$299/month AI customer service solution" sounds like a product. A "25% markup on API costs" sounds like... accounting.

If you read our previous post about escaping the agency trap, this is the model that enables recurring revenue. You're not selling API access with a markup—you're selling a solution with a price tag.

The tradeoff: You absorb the usage variance. If a client's usage spikes, your margin shrinks. If it spikes hard enough, you could theoretically lose money.

This is where budget caps become essential. When you set up fixed-price billing, you also set a cap on actual API spend. If the client's usage approaches that cap, you get alerted. If it hits the cap, the system can either throttle usage or trigger a conversation about upgrading to a higher tier.

The cap is your safety net. Set it at a level where you're still making reasonable margin even in worst-case scenarios.

Real-world example:

"Our AI support package is $299/month, flat rate. That includes the chatbot, email integration, up to 5,000 conversations per month, and ongoing support. You'll never get a surprise bill—it's the same every month. If you consistently need more volume, we have a $499 tier that covers up to 15,000 conversations."

This works because you've productized the offering. There's a clear scope (5,000 conversations), a clear price ($299), and a clear upgrade path ($499 tier). The client doesn't need to think about API costs at all—that's your problem now, and you've priced it to make that problem profitable.

Choosing the Right Model: A Decision Framework

Here's a quick reference for matching pricing models to client situations:

Client Situation	Recommended Model	Why
Usage varies wildly month-to-month	Margin %	You always make your cut, they pay fairly
Enterprise with procurement/compliance	Fixed Fee	Transparent, auditable, shows real costs
Small business wanting simplicity	Fixed Price	One number, no cognitive load
Cost-conscious, watches every dollar	Fixed Fee	They see exactly what AI costs
Values "set and forget"	Fixed Price	Predictable expense they can budget
New client, usage patterns unknown	Margin %	Protects you until you understand their patterns
Long-term client with stable usage	Fixed Price	Convert to subscription once you know the numbers

The model you choose isn't permanent. Many client relationships evolve: start with margin percentage while you learn their usage patterns, then propose a fixed-price package once you have enough data to price it confidently.

The Math: Making This Profitable

Let's get concrete. Here's how to think about pricing in each model:

Margin Percentage: Choosing Your Rate

Industry markups for API reselling typically range from 15% to 40%. Where you land depends on what's included:

15-20%: Bare-bones API access, minimal support
25-30%: Managed service with monitoring and basic support
35-40%: Full-service solution with custom development, priority support, and SLA guarantees

Don't race to the bottom. Clients paying for AI solutions aren't usually shopping on price—they're shopping on trust and results. A 30% margin on a $200 API bill is $60. That's not gouging; that's the cost of running a professional service.

Fixed Fee: Covering Your Overhead

Your fixed fee should cover your operational costs plus profit, independent of usage. Think about:

Time spent on monitoring and maintenance
Support requests and troubleshooting
Infrastructure costs (dashboards, alerting, etc.)
Your profit margin

If you spend an average of 2 hours per month per client on operational tasks, and your time is worth $75/hour, that's $150 in costs. A $200 fixed fee gives you $50 profit regardless of their API usage.

Fixed Price: Building in Safety Margins

Fixed pricing requires you to estimate costs and build in enough buffer to stay profitable even when usage runs high.

Step 1: Estimate average monthly API cost based on expected usage. If you're not sure, start with margin percentage for a few months to gather data.

Step 2: Add your desired profit margin. If API costs average $100 and you want to make $150/month, your base price is $250.

Step 3: Add a buffer for variance. Usage will fluctuate. Add 15-25% to your base price to absorb high months. That $250 becomes $290-310.

Step 4: Set a budget cap. This is your ceiling on actual API spend. Set it at the point where you'd still break even or make minimal profit. If your price is $299 and you want at least $50 profit, your cap is $249.

Step 5: Round to a clean number. $299/month is easier to sell than $287/month.

Building This System (Two Paths)

You've got the strategy. Now you need the infrastructure to execute it.

Path 1: Build It Yourself

It's possible. You'll need:

A proxy layer that routes API calls through your infrastructure so you can track and attribute usage
A database storing per-client usage records, pricing configurations, and billing history
Pricing logic that applies the right calculation based on each client's model
A dashboard so you (and optionally clients) can see what's happening
Alerting to notify you when clients approach limits
Billing integration to turn usage into invoices

This is a real engineering project. Figure 40-80 hours to build something basic, then ongoing maintenance as you add clients and edge cases emerge.

If you have engineering capacity and want full control, it's a valid path. Just don't underestimate the complexity.

Path 2: Use a Platform Built for This

This is where I'll mention that Bizgraph exists specifically for this problem—and I'll be upfront that I'm biased because we built it.

Bizgraph lets you create isolated API keys for each client with built-in pricing models. You pick margin percentage, fixed fee, or fixed price. You set budget caps and alert thresholds. The system tracks usage, calculates costs and revenue, and gives you dashboards showing exactly where you stand with each client.

You skip the infrastructure project and go straight to managing client solutions. The tradeoff is that you're dependent on a platform instead of owning everything yourself.

For most agencies, the build-vs-buy math favors buying. Your time is better spent acquiring clients and building solutions than maintaining billing infrastructure.

But I would say that, wouldn't I?

FAQ

Q: What margin or fee should I start with if I have no idea what's reasonable?

A: Start with 25% margin or estimate 2 hours of work per month times your hourly rate for a fixed fee. These are reasonable starting points that you can adjust as you learn more about each client's actual needs and your actual costs.

Q: Should I show clients the actual API costs?

A: It depends on the relationship. For fixed fee, yes—transparency is the whole point. For margin percentage, it can go either way; some clients appreciate seeing the math, others just want to know what they owe. For fixed price, no—you're selling a product, not itemized costs. The breakdown is irrelevant to the value proposition.

Q: What if a fixed-price client's usage explodes?

A: This is why budget caps exist. Set a cap at your break-even point. If usage approaches the cap, you have a conversation: "Your team is getting great value from the AI—you're on track to exceed the usage included in your current plan. Let's talk about moving to our higher tier." This isn't a crisis; it's an upsell opportunity.

Q: Can I mix pricing models for the same client?

A: Yes. You might charge fixed price for a chatbot (predictable usage) and margin percentage for a research tool (highly variable). Each API key can have its own pricing configuration.

Q: What about clients who want to pay annually?

A: Annual billing works great with fixed price—offer a discount (typically 10-15%) for upfront payment. It's trickier with margin percentage since you're estimating a year of variable costs. If a client wants annual billing on a variable-cost model, consider converting them to fixed price first.

Q: How do I handle the transition if I'm already eating API costs for existing clients?

A: Be direct. "When we started working together, I absorbed the API costs as part of the project. Now that the solution is in production and driving real value, I'd like to move to a sustainable model where you cover the ongoing costs. Here are three options..." Then present margin, fee, and fixed price. Let them choose what fits their preferences.

The Bottom Line

Charging for AI doesn't have to be complicated. It comes down to three questions:

How variable is this client's usage? High variance → margin percentage. Low variance → fixed price is an option.
Does this client want transparency or simplicity? Transparency → fixed fee. Simplicity → fixed price.
What's my minimum acceptable profit? Set your margin, fee, or price to hit that number, then add a buffer.

Pick the model that fits, set it up once, and let the system handle the math.

You built an AI solution that delivers value every day. You deserve to get paid for that value every month—without becoming an accountant in the process.

Bizgraph gives agencies the infrastructure to manage AI solutions across multiple clients—isolated API keys, flexible pricing models, real-time usage tracking, and automated revenue calculations. See how it works →