OpenAI publishes an official price list for its API, so figuring out the real ChatGPT API cost should be easy. Then you actually read the list, and the questions start. What does “$5 per 1M tokens” mean for a chatbot that talks to 200 visitors a day? Do you pay for the model’s “thinking” time? And why do two models with nearly identical names differ 25x in price? 🤔
This guide turns the official price list into real numbers. Every figure below comes straight from OpenAI’s pricing page and model documentation, and the math is worked out per use case: content generation, website chatbots, and customer support automation. By the end, budgeting for the API stops being guesswork.
In a hurry? These are the current flagship text models and their standard rates:
| Model | Input (per 1M tokens) | Cached input | Output (per 1M tokens) |
|---|---|---|---|
| gpt-5.6-sol | $5.00 | $0.50 | $30.00 |
| gpt-5.6-terra | $2.00 | $0.20 | $12.00 |
| gpt-5.6-luna | $0.20 | $0.02 | $1.20 |
Keep reading for the full picture, because the model you pick matters far less than how many tokens your workflow burns. 💸
How ChatGPT API pricing works
The number one thing to know is this: what you pay depends on the number of tokens you send to the model (input) and the number of tokens the model generates (output). Input and output are billed at different rates, and output is always the expensive direction: 6x the input rate on every one of the current models.
Which raises the obvious question:
“Wait, what’s a token?”
A token is a single chunk of text that an AI model processes. For a rough mental estimate, each English word averages about 1.3 to 1.4 tokens, or around 4 characters per token. So a 400-word prompt written in a text editor works out to roughly 550 tokens. It’s a really rough estimate, but good enough for napkin math.
- Tokens include spaces, punctuation, and special characters. “Hello, world!” is four tokens: Hello + , + world + !
- Every API call bills both directions: your input tokens (what you send) and output tokens (what the model responds with).
- If your app resends the chat history with each new prompt, your input token use multiplies with every request. A long conversation gets expensive in a hurry.
Your combined input and output tokens are what ultimately determine the ChatGPT API cost on your invoice. If you want exact counts instead of estimates, OpenAI’s Tokenizer tool shows you precisely how any piece of text splits into tokens, right in the browser:
One more wrinkle before the tables: OpenAI bills in several processing tiers. Standard is the default. Batch and Flex run non-urgent jobs at half price, while Fast mode (formerly Priority processing) gets you quicker responses at double the standard rate. All the per-model numbers in this guide are Standard tier unless noted otherwise.
Current ChatGPT API pricing 💰
OpenAI’s lineup moves fast, and the current headline generation is GPT-5.6. It comes in three sizes that all share the same huge context window (1.05M tokens) and max output (128K tokens):
- gpt-5.6-sol is the flagship, built for complex reasoning and coding work. The plain
gpt-5.6alias always points to it. - gpt-5.6-terra balances intelligence and cost. For most apps, this is the sensible default.
- gpt-5.6-luna is the budget option for cost-sensitive, high-volume workloads, at 1/25 the input price of Sol.
Here’s the master table, Standard tier, per 1M tokens:
| Model | Input | Cached input | Output |
|---|---|---|---|
| gpt-5.6-sol | $5.00 | $0.50 | $30.00 |
| gpt-5.6-terra | $2.00 | $0.20 | $12.00 |
| gpt-5.6-luna | $0.20 | $0.02 | $1.20 |
One important catch: those rates apply to requests with up to 272K input tokens. Go above that threshold and OpenAI’s long-context rates kick in, roughly double on input and 1.5x on output (Sol jumps to $10 input and $45 output, for example). Most everyday apps will never get near that line, but document-heavy workflows should keep it in mind. There’s also a 10% uplift if you opt into regional data-residency processing on newer models.
Older models still on the price list
Plenty of earlier models remain available, and a few are still genuinely useful. Notably, older does not mean cheaper: gpt-4o costs more than Terra on input, and even ancient gpt-3.5-turbo costs 2.5x what Luna does on input.
| Model | Input | Cached input | Output |
|---|---|---|---|
| chat-latest (the model behind the ChatGPT app) | $5.00 | $0.50 | $30.00 |
| gpt-5.5 | $5.00 | $0.50 | $30.00 |
| gpt-5.2 | $1.75 | $0.175 | $14.00 |
| gpt-5.1 / gpt-5 | $1.25 | $0.125 | $10.00 |
| gpt-5-mini | $0.25 | $0.025 | $2.00 |
| gpt-5-nano | $0.05 | $0.005 | $0.40 |
| gpt-4.1 | $2.00 | $0.50 | $8.00 |
| gpt-4o | $2.50 | $1.25 | $10.00 |
| o3 | $2.00 | $0.50 | $8.00 |
| o4-mini | $1.10 | $0.275 | $4.40 |
| gpt-3.5-turbo | $0.50 | n/a | $1.50 |
Text isn’t the only thing on the meter. The realtime voice models bill audio tokens separately (gpt-realtime-2.1 runs $32 input and $64 output per 1M audio tokens), image generation uses gpt-image-2, transcription starts around $0.003 per minute on gpt-4o-mini-transcribe, and Codex users get gpt-5.3-codex at $1.75 / $14. Built-in tools have their own fees too, like web search at $10 per 1,000 calls. If your project is plain text in, text out, you can ignore all of that.
Context limits to be aware of
A model’s context limit is the maximum number of tokens it can handle in a single exchange, counting your prompt, any conversation history you resend, and the response. All three GPT-5.6 models give you a 1.05M token context window with up to 128K tokens of output, which is an enormous amount of room:
| Model | Context window | Max output |
|---|---|---|
| gpt-5.6-sol | 1.05M tokens | 128K tokens |
| gpt-5.6-terra | 1.05M tokens | 128K tokens |
| gpt-5.6-luna | 1.05M tokens | 128K tokens |
Why this matters for your budget:
- Everything in the exchange counts. A 1,000-token system prompt plus 20 messages of history plus the reply all add to the same total.
- Crossing 272K input tokens in one request switches you to the pricier long-context rates mentioned above.
- If you exceed the window, the request fails or gets truncated, and a chatbot with a small effective window “forgets” the start of long conversations.
- Older models have much smaller windows, so check the model reference page before migrating anything.
The practical takeaway: keeping conversations trimmed isn’t just a performance habit, it directly keeps you in the cheaper pricing tier. ✂️
A concrete example of the threshold at work: summarizing a 300K-token pile of documents on Terra would be billed at the long-context rate of $4 per 1M input tokens instead of the standard $2. That one job costs $1.20 in input alone. Split the same documents into two 150K-token batches and both stay under the line, halving the input side of that particular bill.
Reasoning vs API cost
The current flagship models are reasoning models. Before answering, they “think” through the problem, and that thinking happens in tokens too. Reasoning tokens aren’t shown to the user, but they occupy space in the context window and, here’s the kicker, they’re billed as output tokens at the full output rate.
Depending on the problem, a model can generate anywhere from a few hundred to tens of thousands of reasoning tokens for a single answer. A quick example: a hard support question on Sol might produce 300 visible output tokens plus 2,000 reasoning tokens. That’s 2,300 tokens billed at $30 per 1M, so about $0.069 for one reply. The same reply without reasoning would cost $0.009. The thinking is genuinely better on hard problems, but it’s nearly 8x the price here.
You control this dial. The reasoning effort setting runs from none all the way to max, and max_output_tokens puts a hard cap on total generation (reasoning included). One subtlety worth knowing: in multi-step conversations, GPT-5.6 models by default carry available reasoning from earlier turns forward into the next request, so yesterday’s thinking can keep showing up on today’s meter unless you trim or summarize the history.
The strategy writes itself: save Sol’s deep thinking for tasks that deserve it, and route routine questions to Luna or Terra at low or no reasoning effort. Otherwise the thinking budget quietly eats the answering budget. 🧠
Common ChatGPT API use cases and their costs
Time for the part the pricing page can’t give you: what these rates mean for real workloads. Each scenario below does the math on all three current models, Standard tier.
Content generation
Blog posts first. A 900-word article is about 1,200 output tokens, plus a small prompt of maybe 100 input tokens. The per-article ChatGPT API cost works out to roughly $0.04 on Sol, $0.015 on Terra, and $0.0015 on Luna. Publishing 30 AI-assisted articles a month lands at about $1.10, $0.44, or $0.05 respectively. Even the flagship is pocket change for this workload.
For a deeper look at what generating long-form content with AI really costs end to end, there’s a full video walkthrough:
Social media content is shorter still. A punchy post of about 100 output tokens costs around a tenth of a cent on Terra, and a hundred such posts on Luna come to about $0.012. Basically a rounding error. 📱
Product descriptions sit in the middle: feed the model 300 tokens of specs, get a 150-token description back. On Terra that’s about $0.0024 per description, so a 10,000-product catalog costs around $24. On Luna the same catalog runs about $2.40. Volume ecommerce work is exactly where the cheap model shines.
Powering website chatbots
Chatbots are where API costs get real, because every visitor message triggers an API call carrying your system prompt, any knowledge snippets you inject, and the conversation history. A reasonable per-reply estimate is 800 input tokens and 60 output tokens. Five replies per visitor session, 1,000 sessions a day: that’s 4M input and 300K output tokens daily.
Run that through the price list and the spread is dramatic. Sol lands near $29 per day (about $870 a month). Terra comes in around $11.60 per day (about $350 a month). Luna does the same volume for roughly $1.16 a day, or about $35 a month. Same conversations, 25x price difference. And because chatbots resend the same system prompt constantly, prompt caching (covered in the tips section) can shrink the input side even further.
On WordPress, this is exactly where API cost lands on a site owner. Hyve, for example, is ThemeIsle’s own AI chatbot plugin (full disclosure: same company as this blog), and since Hyve 2.0 it offers two ways to power the chat. Hyve Connect needs no OpenAI key at all: the free plan includes 500 chat messages a month, and Hyve Pro raises that to 10,000. Or you plug in your own OpenAI API key and pay OpenAI directly at the token rates above, with no middleman markup. That BYO-key route needs an OpenAI account with paid credit; free-tier keys tend to fail with “Too many requests” errors.
The math above is what decides between the two setups. A busy store fielding thousands of chats a day will blow past any bundled message quota, so a own-key setup on Luna is the cheaper path. A small site with a few hundred chats a month fits inside bundled messages and skips API billing entirely. 🤖
Customer support automation
Automating email support is the classic use case: the model reads each incoming message and drafts a reply. Say each ticket means 200 input tokens and a 300-token drafted response, and the queue runs 500 emails a day. That’s 100K input and 150K output tokens daily, which works out to about $2 a day on Terra ($60 a month), $0.20 a day on Luna ($6 a month), or $5 a day on Sol ($150 a month).
A smart routing setup cuts this further: let Luna handle the routine 90% (order status, password resets, refund policy) and only escalate genuinely tricky tickets to Sol with higher reasoning effort. Most support queues are routine, so the blended bill ends up much closer to Luna’s number than Sol’s. 🦾
Feedback collection follows the same shape at a smaller scale. If 200 customers a day each leave five short comments (about 75 input tokens total) and the model replies with a 100-token summary or thank-you, that’s 15K input and 20K output tokens daily. On Luna the whole feedback operation costs under $0.03 a day, less than a dollar a month.
Additional costs you might face
The token bill is the headline, but a few secondary costs ride along with any API integration. Worth knowing about before they surprise you:
1. Infrastructure
The API itself runs on OpenAI’s servers, but your application still needs somewhere to live, and chatty AI features can push real load. If the site sits on crowded shared hosting, a quality VPS or cloud instance is the usual upgrade. Vultr is one of the top-rated players in cloud servers, and Cloudways is a friendlier managed option if the project runs on WordPress.
2. Tool fees
Giving the model extra abilities isn’t free. Web search costs $10 per 1,000 calls, with the retrieved content tokens billed at model rates on top. File search runs $0.10 per GB of storage per day (first GB free) plus $2.50 per 1,000 calls. Hosted code containers start at $0.03 per 20-minute session. A chatbot that searches the web 5,000 times a day just added $50 to the daily bill, so enable tools deliberately. 🛠️
3. Data transfer
Cloud bandwidth isn’t always free. Incoming traffic (ingress) usually is, but outgoing traffic (egress) gets metered by providers like AWS. If an application makes 10,000 API calls a day and moves 50 KB per call, that’s 500 MB of daily egress. Not scary at small scale, very real at large scale. 🔁
4. Security and compliance
Sensitive data flowing through the integration needs end-to-end encryption: TLS 1.3 in transit, proper key management at rest. Businesses in healthcare or finance should also confirm the integration lines up with their industry’s regulations, which can mean extra data-protection measures and periodic audits. Boring line item, expensive to skip. 🔒
Top tips for optimizing ChatGPT API costs
Small inefficiencies compound fast at API scale. These four habits keep the bill lean without dumbing down the results:
1. Right-size the model (and the tier)
The single biggest lever is model choice, as the chatbot math above shows. Default to Luna for high-volume routine work, step up to Terra when quality starts to matter, and reserve Sol for genuinely hard reasoning or coding. For jobs that don’t need an instant answer (nightly summaries, bulk tagging, report generation), Batch and Flex tiers run at half the Standard price. Fast mode does the opposite at 2x, so only pay for it when latency actually costs you money. ⚡
2. Cache prompts
OpenAI’s prompt caching automatically kicks in on prompts of 1,024 tokens or more: when a request reuses a prefix the service has recently seen, those cached input tokens bill at a much lower rate. On the GPT-5.6 family the discount is a full 10x:
| Model | Standard input (per 1M) | Cached input (per 1M) |
|---|---|---|
| gpt-5.6-sol | $5.00 | $0.50 |
| gpt-5.6-terra | $2.00 | $0.20 |
| gpt-5.6-luna | $0.20 | $0.02 |
Two catches. Cache hits require an identical prefix, so keep the stable content (system prompt, instructions, reference docs) at the front of the prompt and put anything that changes at the end. And on the GPT-5.6 family, writing to the cache costs 1.25x the normal input rate, a small toll that’s easily earned back once the prefix gets reused. A chatbot that sends the same 800-token instruction block all day is the poster child for this. 💾
3. Trim text inputs
Every token string adds to the bill, so pre-process inputs before they go out: strip redundant whitespace, drop boilerplate the model doesn’t need, and keep instructions tight. For long conversations, don’t resend the full history forever. Have a cheap model summarize the conversation so far, then send that summary instead. It keeps you under the context window, under the 272K long-context threshold, and under budget, all at once. ✂️
4. Estimate and cap with tiktoken
tiktoken is OpenAI’s own open-source tokenizer library. It counts (and encodes) tokens locally, with no API call, which makes it perfect for cost guardrails in an app’s backend:
- Estimate the token count of a request before sending it, and show users (or budgets) the projected cost.
- Truncate inputs that would blow past a context limit, instead of paying for a failed call.
- Detect when a conversation nears the window and trigger the summarization trick from tip 3.
- Pair it with a
max_output_tokenscap so a runaway reasoning loop can’t run up the meter.
Measuring first, sending second is the whole game. 📏 And once the integration is live, reconcile the estimates against reality: every API response includes a usage object with the exact input, output, cached, and reasoning token counts, so the actual bill never has to be a surprise.
Final thoughts 🏁
The real ChatGPT API cost comes down to three dials: how many tokens flow in, how many flow out (reasoning included), and which model meters them. For most projects in between, Terra is the balanced pick, Luna is the volume play at 1/25 the input price of Sol, and Sol earns its premium only on work that truly needs deep reasoning.
Beyond the per-token rates, remember the supporting cast: infrastructure, tool fees, bandwidth, and compliance all join the invoice. Then claw the money back with caching, trimmed prompts, and tiktoken guardrails.
To keep building on this, these guides are the natural next stops:
- 👉 The best ChatGPT plugins for WordPress
- 👉 WordPress AI chatbot plugins trained on your own content
- 👉 Creative ways to use OpenAI on WordPress
- 👉 How to start an online business with ChatGPT
Still have questions about estimating ChatGPT API cost for a specific project? Drop them in the comments section below!
FREE GUIDE
4 Essential Steps to Speed Up Your WordPress Website
Follow the simple steps in our 4-part mini series and reduce your loading times by 50-80%. 🚀
