How to Bill Clients for AI API Costs: Pass-Through, Markup or Flat Fee
Quick answer
The simplest way to bill clients for AI API costs is to not carry them at all: have the client open its own OpenAI or Anthropic account, give you a developer role, and set a monthly spend limit, so usage that changes from month to month lands on the client’s card and the client holds the keys and the data. If you pay the provider yourself, bill the usage at cost or with a markup stated in the contract (for example, 15 percent) on its own invoice line, backed by the provider’s usage records, and fold it into a flat fee only when a spend cap and a usage ceiling are written into the deal. As of November 2026, standard input prices on the models compared below run from $0.10 per million tokens on OpenAI’s gpt-6-luna and Anthropic’s Claude Haiku 5.5 to $10 on gpt-6-astra and Claude Fable 5.1, a 100-fold spread, so the model you pick changes the bill far more than the billing method does.

At FreelanceAtlas, we help freelancers price and bill their work. The prices, spend limits and data rules below come from OpenAI’s and Anthropic’s own pricing pages and API documentation, and the tax points from IRS instructions and publications, all checked in November 2026. For the offer side, see How to Become an AI Consultant in 2026: Skills, Offers and Contracts, and for invoice basics, How to Invoice Clients as a Freelancer (Step-by-Step Guide).
This guide is general information, not tax or legal advice. API prices and limits change, so check each provider’s pricing page before you quote, and ask a tax professional how to record costs you pass through to clients.
How to Bill Clients for AI API Costs: The Answer at a Glance
The table compares five ways to handle the API bill on a client project, judged on who pays the provider, who holds the account and what happens when usage jumps.
| Billing model | Who pays the provider | Who holds keys and data | When usage jumps | Fits |
|---|---|---|---|---|
| Client owns the API account | The client, on its own card | The client, with you as a developer | The client pays more, and its spend limit stops a runaway bill | Any client willing to open an account |
| Pass-through at cost | You, then you invoice the exact amount | You, until you hand the account over | You carry the larger bill until the client pays | Short builds and test phases |
| Pass-through with markup | You, plus a stated percentage | You | The markup covers your float and admin time | Ongoing work where you run the account |
| Bundled flat fee | You, inside one monthly price | You | You absorb the overage unless the contract caps it | Steady, predictable usage |
| Allowance plus overage | You, with a usage allowance in the fee | You | The client pays for usage above the allowance | Usage that grows over time |
What OpenAI and Anthropic Charge as of November 2026
OpenAI and Anthropic both price by the token, quoted per million tokens. Input is what your code sends to the model, and output is what the model writes back. At the standard rates below, output costs 5 times as much as input, so a feature that writes long answers costs more than one that reads long documents and replies briefly.
OpenAI API Prices
From OpenAI’s API pricing page, standard rates for prompts of up to 272K input tokens:
- gpt-6-astra. $10.00 input, $50.00 output and $1.00 cached input per million tokens.
- gpt-6.1-sol. $2.00 input, $10.00 output and $0.10 cached input per million tokens. Above 272K input tokens, input rises to $4.00 and output to $15.00.
- gpt-6.1-terra. $1.00 input, $5.00 output and $0.05 cached input.
- gpt-6-luna. $0.10 input, $0.50 output and $0.01 cached input.
Batch rates for these models are half the standard rates: gpt-6.1-sol drops to $1.00 input and $5.00 output. Web search costs $10.00 per 1,000 calls, plus the search content tokens at the model’s rates.
Anthropic API Prices
From Anthropic’s Claude pricing page, per million tokens:
- Claude Opus 5.5. $4 input and $20 output.
- Claude Sonnet 5.5. $2 input and $10 output.
- Claude Haiku 5.5. $0.10 input and $0.50 output for prompts up to 100,000 tokens, and $0.50 input and $2.50 output for prompts over 100,000 tokens.
- Claude Fable 5.1. $10 input and $50 output.
Cache hits on Opus 5.5 and Sonnet 5.5 cost 0.05 times the base input price, so $0.10 per million on Sonnet 5.5, and the Batch API takes 50 percent off input and output. Web search costs $10 per 1,000 searches. Two notes on that page matter for estimates. Claude 4.7 and later models use a newer tokenizer that produces about 30 percent more tokens for the same text. And prices do change: Anthropic had scheduled Claude Sonnet 5 to rise to $3 input and $15 output on September 1, 2026, then kept it at $2 and $10.
Option 1: The Client Owns the API Account
This is the cleanest setup: the client signs up, pays the provider directly and gives you access, so you never front money or argue about usage.
Setup on each platform:
- OpenAI. The client invites you to its organization from the Team page and creates a project for your build. OpenAI’s production best practices page says you can limit user access to a project and set rate and spend limits per project, and its spend limits guide says that once a project reaches its hard limit, requests return a 429 error with the code project_spend_limit_exceeded. Spend alerts alone “do not enforce a cap,” and enforcement is not instant, so recorded spend can slightly pass the limit. OpenAI’s rate limits guide also sets an approved monthly usage limit by tier: $500 a month on Build (after $5 in credit purchases), $5,000 on Launch (after $100) and $200,000 on Grow (after $500).
- Anthropic. The client creates a workspace for the project and adds you with the Workspace Developer role, which Anthropic’s workspaces guide says can create and manage API keys and use the API. The client sets a monthly spend limit and alerts on that workspace. Spend limits cannot be set on the Default Workspace, so use a new one. Anthropic’s rate limits page caps monthly spend at $500 on the Start tier, $1,000 on Build and $200,000 on Scale, and usage pauses until 00:00 UTC on the first day of the next month once an organization reaches its tier cap.
The data stays with the client’s account, under the client’s agreement with the provider. OpenAI’s data controls guide says data sent to the API is not used to train its models by default, and abuse monitoring logs are kept for up to 30 days by default. Anthropic’s privacy center says that by default it does not use inputs or outputs from commercial products such as the Anthropic API to train its models. At handover, the client removes your access, and no key or billing account has to move.
The cost to you is setup time, often a short call while the client adds a card. Bill that time in your project fee.
When You Pay the Bill: Pass-Through, Markup or Flat Fee
If the client will not open an account, or you run the feature for them after launch, you pay the provider and recover the cost. Give every client its own OpenAI project or Anthropic workspace, so each bill can be traced to one client. Anthropic allows up to 100 workspaces per organization by default, and OpenAI applies project hard limits only to traffic billed to that project.
Pass-Through at Cost
Bill exactly what the provider charged for that client’s project or workspace, on its own invoice line, with the provider’s usage export or invoice attached. This is the easiest to defend, but you earn nothing for fronting the money, and you carry the cost from the day you pay the provider until the client pays you.
Markup on API Costs
A markup pays you for the float, the monthly reconciliation and the risk of a client who pays late. State it in the contract as a percentage, for example 15 percent, and show it either as a separate line or as part of an “AI usage” line the contract describes. The risk is a markup the client finds later on a provider invoice, so put the percentage in writing first.
Bundled Flat Fee
A flat monthly fee that includes AI usage is easy to sell and easy to invoice. It works only when usage is steady and the contract includes a ceiling, such as a set number of documents processed or conversations handled each month. Price it from a real month of logs, not a guess, and review it each quarter. Freelance Pricing Packages shows how to build tiers with different allowances, and Value-Based Pricing for Freelancers covers pricing the feature by what it saves the client.
Whichever model you choose, put it in the contract. A clause to adapt, not legal advice:
AI usage costs. The Project uses third-party AI services billed by usage.
Option A: The Client opens and pays for its own provider accounts and grants the Developer access. The Developer does not pay or bill for usage.
Option B: The Developer pays the provider and invoices the Client monthly for actual usage, plus 15 percent, with the provider’s usage report attached.
Usage costs above $300 in any month require the Client’s written approval in advance. The Developer will set a provider spend limit at that amount.
Provider price changes apply from the date they take effect.
Our contract generator drafts the rest of the agreement around it.
Usage That Changes Every Month: Caps, Alerts and Overages
Set the provider spend limit at the ceiling written in the contract, decide in advance who may raise it, and build the feature to show a clear message when the limit is reached.
Usage can change fast: a launch, a marketing email or a bug that calls the API in a loop can multiply the bill in a day. Plan for it in four steps:
- Estimate a range. Price a quiet month, a normal month and a busy month from test logs, and quote all three.
- Set a hard limit at the contract ceiling. On OpenAI, a project hard limit. On Anthropic, a workspace spend limit with alerts below it.
- Know what the app does at the limit. Anthropic returns HTTP 400 with “You have reached your specified workspace API usage limits” when your own limit is hit, and HTTP 429 when the organization reaches its tier cap. OpenAI returns 429 errors. Show users a plain message instead of a crash.
- Name who raises the cap. The contract should say the client approves any increase in writing before you change the limit.
Hourly overage for your own time follows the same logic as scope changes on any fixed job, covered in Fixed-Price Project Taking Twice the Hours.
Invoices and Taxes on Passed-Through API Costs
Show API usage on its own invoice line with the month, the provider and the amount, and keep the provider’s invoice behind it. Our invoice generator handles a separate usage line.
For a US freelancer, the IRS points that apply are these:
- What you receive is business income. IRS Publication 334 says that if there is a connection between any income you receive and your business, the income is business income, and that you must report all business income, including income not reported to you on a form.
- What you pay the provider can be an expense. IRS Publication 583 says a business expense must be both ordinary and necessary to be deductible, and lists invoices and receipts as supporting documents. Keep the provider invoices for each client.
- What the client reports. The Instructions for Forms 1099-MISC and 1099-NEC (December 2026 revision) set the 1099-NEC threshold at $2,000 for tax years beginning after 2025, with inflation changes possible from 2027. They list “payment for services, including payment for parts or materials used to perform the services if supplying the parts or materials was incidental to providing the service.” Payments by credit card or through third-party networks are reported on Form 1099-K instead.
When the client owns the account, none of this touches your books: the API bill is the client’s own expense, and you report only your fees.
Pricing AI-Written Content Fixes on Fiverr
Price the fix by the time it takes and the result the buyer needs, not by the word count of the AI draft, and quote only after you have seen the draft.
A buyer may assume an edit should cost less than writing from scratch. Sometimes it does: a clean draft that needs facts checked and a few lines tightened is a light job. A draft with wrong facts, a repeated structure and no clear point can take as long as a rewrite. Set up the offer in three levels:
- Light edit. Fix errors, check facts and smooth the flow, with the structure kept.
- Heavy edit. Restructure sections, replace weak parts and add sourcing.
- Rewrite. Use the draft as notes and write the piece again.
For example, a writer who charges $50 an hour asks for the draft and edits the first 500 words of a 1,500-word article in 40 minutes. The whole article will take 3 x 40 = 120 minutes, or 2 hours, so a heavy edit is $100. Writing from scratch takes this writer 4 hours, or $200. The edit costs the buyer half, which is less than writing, but it is not the near-zero price some buyers expect. Show that comparison in the quote. For the wider method, see How to Price Freelance Services in 2026.
Which One Fits Your Situation
- If the client has a company card and an IT contact, then have the client own the API account and set a spend limit.
- If you are prototyping for a few weeks, then pay the provider yourself and bill usage at cost from a separate project or workspace.
- If you run the feature for the client after launch, then bill usage monthly with a stated markup and a usage report.
- If usage is steady and you have a month of real logs, then offer a flat fee with an allowance and an overage rate.
- If usage could spike, then set a hard spend limit at the contract ceiling and write who approves raising it.
- If the feature handles the client’s customer data, then use the client’s own account so the data stays under the client’s agreement with the provider.
- If a Fiverr buyer wants an AI draft fixed cheaply, then time a sample and quote a light edit, heavy edit or rewrite.
Worked Example: A Support Chatbot With Usage That Swings
For example, a freelancer builds a support chatbot on Claude Sonnet 5.5, at $2 input and $10 output per million tokens as of November 2026. In a normal month it uses 30 million input tokens and 3 million output tokens. In a busy month it uses 75 million input tokens and 7.5 million output tokens.
- Normal month. 30 x $2 = $60 for input, plus 3 x $10 = $30 for output, so $90.
- Busy month. 75 x $2 = $150 for input, plus 7.5 x $10 = $75 for output, so $225.
Here is what the client pays for usage under each model:
- Client owns the account. The client pays Anthropic $90 and $225 directly. The freelancer bills only the agreed fee for the work.
- Pass-through at cost. The freelancer invoices $90, then $225.
- 15 percent markup. $90 x 1.15 = $103.50, and $225 x 1.15 = $258.75.
- Flat $150 a month for usage. In the normal month, the freelancer keeps $60 ($150 minus $90). In the busy month, the freelancer loses $75 ($225 minus $150).
- $150 allowance plus overage at cost plus 15 percent. In the busy month, the overage is $75, billed as $75 x 1.15 = $86.25, so the client pays $150 + $86.25 = $236.25.
Now change the model. The same traffic on Claude Haiku 5.5, with prompts under 100,000 tokens, costs 30 x $0.10 + 3 x $0.50 = $3 + $1.50 = $4.50 in the normal month and 75 x $0.10 + 7.5 x $0.50 = $7.50 + $3.75 = $11.25 in the busy month. If the cheaper model answers well enough, the billing question shrinks from hundreds of dollars to about $11. Test it before you choose how to bill.
Traps When You Pay the API Bill
- Your card on a client’s live app with no limit. A loop in the code or a traffic spike bills you first. Set a hard limit on every client project or workspace.
- One key for every client. Shared keys make it impossible to split the bill. Use one OpenAI project or Anthropic workspace per client.
- Keys left behind at handover. If the client’s app still calls the API with your key, you keep paying after the contract ends. Move the client to its own account before the last invoice.
- A markup the contract never mentions. State the percentage in writing before the first invoice.
- Quoting usage costs with no date. Provider prices change, so date every estimate and say price changes pass through.
- Long prompts that cross a price line. Claude Haiku 5.5 costs 5 times as much for prompts over 100,000 tokens, and gpt-6.1-sol input doubles above 272K input tokens.
- Treating a spend alert as a cap. OpenAI says spend alerts do not enforce a cap. Only a hard limit stops traffic.
Conclusion
The best answer to billing a client for AI API costs is usually to keep the bill off your books: the client opens its own OpenAI or Anthropic account, gives you developer access and sets a spend limit. When you do pay the provider, bill usage on its own line at cost or with a markup the contract states, and use a flat fee only with a usage ceiling and a hard limit at the provider.
As of November 2026, the same busy month of traffic can cost $11.25 on Claude Haiku 5.5 or $225 on Claude Sonnet 5.5, so test cheaper models before you set a price. Keep the provider invoices for every client, report what clients pay you as business income, and date every usage estimate you send.
Key Takeaways
- Having the client own the OpenAI or Anthropic account, with you as a developer and a spend limit set, removes the API bill from your books.
- If you pay the provider, bill usage on its own invoice line at cost or with a markup stated in the contract, for example 15 percent.
- As of November 2026, standard input prices on the models in this guide run from $0.10 per million tokens on gpt-6-luna and Claude Haiku 5.5 to $10 on gpt-6-astra and Claude Fable 5.1.
- OpenAI spend alerts do not stop traffic, so set a hard limit on each project, and on Anthropic set a spend limit on a workspace other than the Default Workspace.
- A flat fee lost $75 in the busy month of the worked example, while an allowance plus overage charged the client $236.25 for the same usage.
- The 1099-NEC threshold is $2,000 for 2026 payments, and the IRS treats income connected to your business as business income.
Frequently Asked Questions
How should I bill a client for the AI API costs on a project I am building for them?
The simplest route is for the client to open its own OpenAI or Anthropic account, add you as a developer and pay the provider directly. If you pay instead, invoice usage monthly on its own line, at cost or with a markup the contract states, and attach the provider’s usage report. Use a flat fee only with a written usage ceiling.
Should my client use their own OpenAI or Anthropic API key instead of mine?
Yes, when the client can set one up. The client pays the provider, sets the spend limit and keeps the account and data after you leave. On OpenAI, the client invites you to its organization and limits your access to one project, and on Anthropic, it adds you to a workspace with the Workspace Developer role.
Is it okay to mark up API costs when I bill a client?
Yes, if the contract says so before the first invoice. A stated markup, for example 15 percent, pays you for fronting the money and reconciling usage each month. The problem case is a client who finds an unstated markup by comparing your invoice with the provider’s.
How do I stop a client’s AI feature from running up a huge API bill?
Set a hard spend limit at the provider equal to the monthly ceiling in your contract. On OpenAI that is a project hard limit, since spend alerts alone do not stop traffic, and on Anthropic it is a workspace spend limit. Build the feature to show a clear message when the limit is reached.
How should I price fixing AI-written content on Fiverr when buyers think it should cost less than writing from scratch?
Ask for the draft, time how long a sample section takes to fix, and quote by your time and the result needed. Offer a light edit, a heavy edit and a rewrite at different prices. Show the buyer the comparison, such as a 2-hour heavy edit at $100 against a 4-hour rewrite at $200.
Written by Samir Badawy
140 guides on FreelanceAtlas. Read them all