OpenAI API Billing: Prepaid Credits, Why Card Binding Fails, and the Route That Needs No Card (2026)
The OpenAI API is prepaid credits, not a subscription. How billing works, why adding a card fails, how to keep costs from running away, and an alternative that needs no card at all.
1. First: the API and Plus are two separate wallets
This is the most common beginner misunderstanding and the most expensive in time. ChatGPT Plus is a subscription for people using the product in a browser or app. The OpenAI API is an interface for developers calling it from code, managed separately at platform.openai.com with its own card and its own balance. The money does not cross over — subscribe to Plus and your API balance is still zero, and calls still fail; load API credit and the web product is throttled exactly as before. Confusing the two sends people looking for the problem in entirely the wrong place. The test for which you need is one sentence: are you typing into a chat box, or calling from a program?
2. The billing model: prepaid, not postpaid
The API uses prepaid credits: you load an amount, calls draw against it per token, and it stops when empty. Two consequences are worth knowing in advance. ① You never accrue a debt — when the balance hits zero, calls simply fail, so production systems need balance monitoring rather than waiting for an error in the logs to tell you. ② Loading credit requires a card, and that step is a higher hurdle than most people expect. One more thing about the meter: tokens are billed both directions, input and output, and a long conversation carries its entire history back into the input on every turn — which is why the first invoice often surprises people who were only counting what the model wrote.
3. Why attaching a card fails
What matters is not the card network but the issuing institution's country, read from the first six to eight digits of the card number, the BIN. Cards issued in many markets carry a high cross-border decline rate, entirely independently of the Visa or Mastercard logo. So "this is a Visa, it should work" is the wrong inference, and trying a second card from another local bank will not change the outcome. The variable to change is the BIN. Two other common causes sit alongside it: a careless or inconsistent billing address (inventing a plausible US address, or entering a different one each time on the same account, is a common cause of failed charges), and an account flagged by repeated failures, after which even a perfectly good card keeps being refused.
No overseas card needed: cocodot's OpenAI-compatible API — switch your base_url to call the models on sale.
Top up via Alipay / WeChat Pay (RMB), USDT / USDC · billed per token · switch your base_url to connect
4. Route one: attach a US-BIN virtual card
The steps: ① sign up at cocodot and top up the wallet — Alipay works, and current fees are published at cocodot.co/pricing; ② issue a US-BIN virtual card (new cards are Mastercard, BIN 537872 or 555659) and move balance onto it, remembering that wallet balance is not card balance; ③ at platform.openai.com go to Billing → Payment methods, add the card, and use a complete billing address that is genuinely yours (the card is not tied to a personal address), keeping the same one for the same account and never one found online, someone else's, or a made-up one; ④ once the card attaches, load credit under Add to credit balance. Load a small amount the first time to prove the whole chain works, then scale up once it does. The same card has also had successful charges on ChatGPT subscriptions, Claude and OpenRouter, so there is no need to issue one per platform; for any other platform, try a small amount first.
5. Route two: skip the card entirely with a compatible relay
If your code is written against the OpenAI SDK or any OpenAI-compatible format, there is a shorter path: point base_url at a relay that accepts local payment methods and no card is needed at all. cocodot's API works this way — set base_url to https://cocodot.co/api/ai/v1, supply your key, and your existing code does not change by a line; the same key also reaches Claude and Gemini, so you are not opening an account and attaching a card at every vendor in turn. Verifying your email grants a small trial credit, usable after your first top-up, so a small top-up is enough to prove the path before you commit more. Where the two routes divide: if you need the official OpenAI account itself — for features only exposed there — take route one. If you only want to call models from code, take route two.
6. Keeping costs under control: three things to set up
The real risk with an API is not that it is expensive, it is that it runs away — one infinite loop or one unbounded batch job can drain a balance while you sleep. Three things are worth doing before that happens. ① Set a hard monthly cap and an alert threshold under Usage limits; that is your last line of defence. ② Match the model to the task — classification, extraction and formatting on a cheap model, the flagship only for genuinely hard work; this alone usually removes most of the bill. ③ Control context length, because replaying an entire conversation into the input on every turn is the most invisible form of waste — truncate or summarise. Prepaid cards give you one more layer for free: the card balance is itself a hard ceiling, so even a runaway job cannot spend past it.
7. How to read the common errors
Insufficient balance — the call fails outright; check credit balance in Billing, because the API does not let you run a tab. Authentication failures — verify the key itself, that you are not pointing at the wrong organisation or project, and that the key has not been rotated out. Rate limiting — this is a concurrency and frequency limit, not a balance problem; reduce concurrency or add backoff with retries. New accounts usually start at a lower tier and move up as spend accumulates. Card attachment failures — work through the three causes in section three in order, and stop after two or three attempts rather than hammering the form into a risk flag.
'Your credit card was declined. Try a debit card instead' — what to check
That line is a generic decline message on the OpenAI checkout. It does not mean you must use a debit card, and it does not name the cause. Check in this order: the billing address is right — with your own bank card it should match the address your bank holds, while a cocodot virtual card is not tied to a personal address, so use a complete address that is genuinely yours and keep the same one for the same account rather than switching to an invented one; international and online use is enabled and your limit covers the authorization hold; the phone number that receives 3-D Secure codes is current; and the card's issuing country and type are accepted here. If the first three are clean and it still fails, the fourth is likely the cause and only a card on an accepted range will fix it. After two failures, wait a day. Our card has a tested record on OpenAI, but a small first payment is still the sensible start.
ChatGPT Plus and the OpenAI API are different products
| ChatGPT Plus | OpenAI API | |
|---|---|---|
| Where you use it | The chat interface, web and app | Inside your own code |
| How it bills | Fixed monthly fee, with usage caps | Prepaid credits, drawn down per token |
| When usage is lumpy | You pay in quiet months too | A quiet month costs almost nothing |
| Callable from a program | No | Yes — that is what it is for |
| When the balance runs out | Not applicable | Calls fail immediately; you never owe money |
| Paying for it | A card charged monthly | A card plus a prepaid balance, or an OpenAI-compatible relay |