Cheapest OpenAI API model in 2026: gpt-5-nano vs gpt-6-luna

The cheapest OpenAI text model on its pricing page is gpt-5-nano: $0.05 per 1M input tokens and $0.40 per 1M output tokens. Inside the newer GPT-6 line, the cheapest is gpt-6-luna at $0.10 in and $0.50 out. Those numbers come from OpenAI's pricing page, checked on 28 October 2026. The page carries no publication date, so the check date is the one to trust.

But a low price per token is not the same as a low price per task. For small, high-volume jobs, open-weight models on CheapTokens, such as GLM-5.3-Flash and DeepSeek-V4-Flash, come out lower in total. Below you can see it on a concrete job, then plug in your own numbers.

The OpenAI price ladder, from the bottom#

All prices are per 1M tokens, standard tier, short context (up to 272K input tokens). The last column is a calculation for one concrete job: 1,000 requests, each with 500 input and 200 output tokens. Think of a support bot that tags tickets.

Two things stand out. First, gpt-5-nano has the lowest input price and ties gpt-4.1-nano on output, so if you stay on OpenAI and the task is simple, it is the starting point. Second, gpt-4o-mini, which many projects picked as a cheap model, now costs more than gpt-5-nano on input and on output. If that is your model, you have a cheaper option without leaving OpenAI.

Above the table sit gpt-4.1-mini ($0.40 / $1.60) and gpt-5.4-mini ($0.75 / $4.50). Bigger tiers for contrast: gpt-6.1-terra at $1 / $5 (we covered it in GPT-6.1 Terra API price), gpt-6.1-sol at $2 / $10 and gpt-6-astra at $10 / $50. One caveat from the same page: regional-processing endpoints carry a 10% uplift for models released on or after 5 March 2026. The page lists prices only, so check each model's own page for context size and limits before you move a task.

Where the money goes in 1,000 small requests#

Take the ticket-tagging bot. Each request sends about 500 tokens (the instruction plus the ticket) and gets about 200 back. On gpt-5-nano, 1,000 of those cost:

• Input: 0.5M tokens × $0.05 = $0.025
• Output: 0.2M tokens × $0.40 = $0.08
• Total: $0.025 + $0.08 = $0.105

Look at the split. The short answer is less than a third of the tokens, but it is $0.08 of the $0.105. That's the catch with cheap-model shopping: the output price decides the bill more often than the input price does. If you want the longer version of that idea, input vs output tokens walks through it.

OpenAI also lists a cached-input rate: $0.005 per 1M for gpt-5-nano (how that works is in what is prompt caching). Say your whole 500-token input is a repeated prompt and gets cached. Input drops to 0.5M × $0.005 = $0.0025, and the job costs $0.0025 + $0.08 = $0.0825. The bill barely moves, because the 200 output tokens still cost $0.08.

Try the same arithmetic at a bigger scale:

The same job on open-weight models#

Now the same 1,000 requests of 500 in and 200 out, priced on CheapTokens at today's rates:

In numbers: GLM-5.3-Flash takes $0.018, DeepSeek-V4-Flash $0.0275 and MiniMax-M2.7 $0.055. Put that next to the $0.105 for gpt-5-nano. The table is live, so it follows the current price list. GLM-5.3-Flash has a 390K context and answers up to 8,192 tokens, which is plenty for a tag or a short reply. DeepSeek-V4-Flash has a 380K context and answers up to 32,768 tokens, which matters when the output is a report or a long piece of code. Both keep one price at any hour, with no peak pricing.

One more scenario, a chatbot that is still on gpt-4o-mini. Say each chat sends about 1,200 tokens (history plus the new question), gets 250 back, and you serve 3,000 chats a day. On gpt-4o-mini that is 3.6M input tokens × $0.15 = $0.54 and 0.75M output tokens × $0.60 = $0.45, so $0.99 a day. On gpt-5-nano the same day is 3.6M × $0.05 = $0.18 plus 0.75M × $0.40 = $0.30, so $0.48. Here's the same traffic on CheapTokens; change the numbers to match your bot:

Switching takes three small changes#

CheapTokens speaks the OpenAI API, so the code you have keeps working. You change the base URL, the key and the model id. Take the id from the docs, because providers name models differently. For GLM-5.3-Flash it is zai-org/GLM-5.3-Flash, and the base URL is https://api.cheaptokens.dev/v1.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key="YOUR_CHEAPTOKENS_KEY",
)

resp = client.chat.completions.create(
    model="zai-org/GLM-5.3-Flash",
    max_tokens=20,
    messages=[
        {"role": "system", "content": "Tag the ticket as billing, bug or other. Reply with one word."},
        {"role": "user", "content": "I was charged twice for the same order."},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage)

curl https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPTOKENS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org/GLM-5.3-Flash",
    "max_tokens": 20,
    "messages": [
      {"role": "system", "content": "Tag the ticket as billing, bug or other. Reply with one word."},
      {"role": "user", "content": "I was charged twice for the same order."}
    ]
  }'

Run it on 50 of your real tickets and read the answers yourself. The usage field in each response gives the exact input and output token counts, and those two numbers are all the calculator above needs. Keys, balance and the first call are in your first API request.

Which one for which job#

Whichever you pick, test it on your own examples before you move the whole workload. The price table tells you what a token costs; only your data tells you whether the answers are good enough. Current prices for every model are on the pricing page, and how much AI tokens cost puts 1M and 10M token budgets side by side.