How do you use GPT-5.4 mini and nano to cut costs?

Most applications built on AI models send the same kinds of request again and again, and most of those requests are easy. If every one goes to the largest model, you pay top price for work a smaller model would do just as well. Routing fixes that: your code decides, request by request, which model should answer.

GPT-5.4 mini and GPT-5.4 nano, released on March 17, make routing more attractive than before. OpenAI describes mini as more than twice as fast as GPT-5 mini and close to the full GPT-5.4 on some coding and computer-use tests, and recommends nano for classification, data extraction, ranking and simple coding helpers.

The prices that make routing worth it

These are OpenAI's published API prices, per million tokens. A token is a small chunk of text, often a whole word or part of one; you pay separately for tokens you send (input) and tokens the model writes (output).

Nano's input price is 8% of GPT-5.4's, and mini's is 30%. The gap is just as large on output, which matters because answers are often the expensive part.

Prices are not the whole story, though. OpenAI's own scores show where the small models fall behind. On OpenAI's MRCR long-context test, for example, which asks a model to retrieve several matching items from a long input, GPT-5.4 scored 86% on inputs of 64,000 to 128,000 tokens, while mini and nano scored under 48%. So keep long, document-heavy work on the large model.

A worked example: a three-tier router

A help-desk tool answers questions about a software product. Some questions are simple ("How do I reset my password?"), some need explanation, and a few involve tricky troubleshooting. The router asks nano to grade each request, then sends it on.

from openai import OpenAI

client = OpenAI()   # reads OPENAI_API_KEY from the environment

TIERS = {"easy": "gpt-5.4-nano", "medium": "gpt-5.4-mini", "hard": "gpt-5.4"}

GRADER = ("Rate how hard this support question is to answer well. "
          "easy = a fact or a single step from the docs. "
          "medium = needs explanation or several steps. "
          "hard = troubleshooting, ambiguity, or anything about billing or data loss. "
          "Reply with one word: easy, medium or hard.")

def grade(question):
    r = client.responses.create(model="gpt-5.4-nano", instructions=GRADER, input=question)
    level = r.output_text.strip().lower()
    return level if level in TIERS else "hard"      # unsure? play it safe

def answer(question, docs):
    level = grade(question)
    r = client.responses.create(
        model=TIERS[level],
        instructions="Answer using only the documentation provided. If it isn't there, say so.",
        input=f"Documentation:\n{docs}\n\nQuestion: {question}")
    print(level, TIERS[level], r.usage.input_tokens, r.usage.output_tokens)
    return r.output_text

Two design choices keep it safe. Anything the grader can't label clearly goes to the large model, so a confused router costs money rather than quality. And the print line records which model answered and how many tokens it used, which is the data you need to check the savings.

The cost comparison

Here is an illustrative month: 100,000 questions, each sending about 1,500 tokens and receiving about 300. Assume the grader marks 60% easy, 30% medium and 10% hard. All figures are calculated from the list prices above; real token counts will vary.

The router's total includes about $31 for the grading step itself, since nano reads each full question once. Against sending everything to GPT-5.4, the saving is about 72%, while the hardest tenth of questions still gets the strongest model. Sending everything to mini costs a little more than routing and gives the hard questions a weaker answer.

Which jobs can a nano model handle?

Nano is built for short, well-defined tasks with a clear right answer: sorting items into categories, pulling fields such as names, dates or amounts out of text, ranking a list of results, and acting as a quick helper inside a larger agent. The grader in the example is a typical nano job. It reads the input, picks one label from a fixed list, and stops.

It is a weaker choice when a task needs long reasoning, broad knowledge or careful reading of very long documents. OpenAI's published numbers show the gap: on OSWorld-Verified, a test of operating a computer from screenshots, nano scored 39%, against 72% for mini and 75% for GPT-5.4. For that kind of work, mini is the more sensible budget option.

The safest way to find nano's limits is to measure them. Run the same 100 tasks through nano and through a larger model, compare the outputs, and move a task down to nano only when its error rate is one you can live with. Keep a fixed output format, such as a single word or a short JSON object, so your code can check every answer automatically and send anything malformed to a larger model.