GPT 5 API Cost Analysis: What 10,000 Queries Really Cost

GPT-5’s headline per-token pricing looks cheap. What a structured-extraction workload actually costs is a different number.

Force a general-purpose LLM to return structured JSON — citations, source URLs, schema-compliant fields — and the system-prompt tax stacks up fast. We ran 10,000 structured-search queries against GPT-5 and GPT-5-mini to measure it. The per-thousand cost lands well above any back-of-envelope estimate.

This GPT-5 API cost analysis walks through four things. First, the methodology and the real token counts. Second, the resulting per-thousand-query pricing.

Third, how the numbers compare against a purpose-built SERP extraction API. Fourth, what changed in the 2026 model lineup — the current pricing section below has the up-to-date rates. Together they let you decide whether the LLM-as-extractor pattern fits your workload.

The problem with structured outputs from general-purpose LLMs

Getting structured, reliable output from a general-purpose model like GPT-5 takes real context overhead on every request. You have to specify the output format, whether that is JSON, XML, or schema constraints. You have to pin down source and citation formatting rules. You add model behavior guidelines, search-query context, confidence-scoring instructions, and error-handling protocols.

All of that context gets billed on every single request. At low volumes the overhead is invisible. Past a few hundred thousand requests per month, it becomes the dominant cost driver.

OpenAI’s own Structured Outputs feature helps with reliability — it “ensures the model will always generate responses that adhere to your supplied JSON Schema,” so you stop paying for retries on malformed output. It does not, however, remove the tokens. The schema and its instructions still ride along on every request and are billed as input. Any honest GPT-5 API cost analysis has to price that overhead in, not just the headline per-token rate.

Test methodology

We ran 10,000 real-world queries representative of brand monitoring and competitive-analysis workloads.

Test parameters

• Total queries: 10,000
• Average input tokens: 463 per query (measured in OpenAI’s API playground)
• Average output tokens: 1,676 per query (measured in OpenAI’s API playground)
• Query type: structured search results with citations
• Use case: brand monitoring and competitive analysis

What we measured

• Total token consumption (input + output)
• Per-model API cost
• Response quality and consistency
• Processing time differences

The system prompt challenge

To get reliable structured outputs from the OpenAI API, we needed a comprehensive system prompt. Here is the actual prompt used in the test:

You are an API backend model that must always return responses in a strict JSON schema.

Your goal is to produce comprehensive, deeply informative, and structured content — at least several paragraphs long — while respecting the format rules below.

When given a user query:
1. Produce a long, detailed answer with clear explanations, comparisons, and examples.
2. Include both:
   - A markdown version (formatted with headers, bold, lists, tables, etc.)
   - A plain text version (identical content but without markdown formatting)
3. Include at least 3 to 7 credible sources, each with:
   - position (integer starting at 0)
   - label (title or entity name)
   - url (credible or official site)
   - description (short summary of the source)
4. Include 3 to 6 search queries that could help someone find this answer online.
5. Include the model used in format `"model": "gpt-5-mini"`.
6. Return nothing outside the JSON — no commentary or extra lines.

Your output must always follow this structure:

{
  "success": true,
  "result": {
    "markdown": "string",
    "text": "string",
    "sources": [
      {
        "position": number,
        "label": "string",
        "url": "string",
        "description": "string"
      }
    ],
    "searchQueries": ["string"],
    "model": "string"
  }
}

### Additional style and length requirements:
- The answer should be at least 250–400 words long.
- Use factual, neutral, and informative tone.
- Markdown version should include:
  - A bolded introductory sentence
  - Bullet points or numbered lists when relevant
  - Subheadings for structure (e.g., "### Top Models", "### Range and Performance")
- Plain text version should preserve the same logical flow but without markdown syntax.

If information is missing, return an empty string or empty array instead of omitting fields.

No explanations or reasoning outside the JSON are allowed.

The prompt covers a lot of ground. It pins a strict JSON schema and 250–400 words of answer content. It demands both a markdown and a plain-text version.

It also requires 3–7 cited sources with metadata and 3–6 follow-up search queries. And it sets a hard rule against any commentary outside the JSON. None of that is optional if you want output a downstream system can parse without cleanup.

It comes out to 382 tokens by itself, and it’s sent with every single request. At 10,000 requests that’s 3.82M tokens of pure overhead before the actual user query enters the picture.

GPT-5 cost calculation breakdown

Based on the 10,000-query test:

Token consumption

• Average input tokens (including system prompt): 463 × 10,000 = 4,630,000
• Average output tokens: 1,676 × 10,000 = 16,760,000
• Total input tokens: 4,630,000
• Total output tokens: 16,760,000

GPT-5 pricing — these are the GPT-5 launch rates that were in effect at the October 2025 test date. OpenAI has since retired the plain gpt-5 model in favor of the GPT-5.4 and GPT-5.5 families. See the 2026 pricing update below for the current rates.

• Input tokens: $1.250 per 1M
• Output tokens: $10.000 per 1M

Cost calculation

• Input cost: 4.63M × $1.250 = $5.79
• Output cost: 16.76M × $10.000 = $167.60
• Total cost for 10,000 queries: $173.39
• Per thousand requests: $17.34

How that compares to a purpose-built SERP extraction API

A specialized SERP extraction API ships the structured-output guarantees as part of the product. No per-request system-prompt tax, no JSON-schema reinforcement on every call. Using cloro as the comparison point at 5 credits per structured search:

Plan	GPT-5 via OpenAI API	cloro cost (5 credits × CPM)	Difference
Hobby (250K requests)	$4,335	$500 (5 × $0.40)	$3,835
Business (3.3M requests)	$57,222	$4,950 (5 × $0.30)	$52,272

Per-thousand: $17.34 (GPT-5) vs $2.00 (cloro Hobby) vs $1.50 (cloro Business). The gap widens with volume because the system-prompt overhead is a fixed per-request tax on the LLM side and absent on the extraction-API side.

GPT-5-mini cost analysis

We ran the same test against GPT-5-mini for the cheaper model comparison.

GPT-5-mini pricing — again the October 2025 launch rates for the now-retired gpt-5-mini. The 2026 update maps these onto today’s gpt-5.4-mini tier.

• Input tokens: $0.250 per 1M
• Output tokens: $2.000 per 1M

Cost calculation

• Input cost: 4.63M × $0.250 = $1.16
• Output cost: 16.76M × $2.000 = $33.52
• Total cost for 10,000 queries: $34.68
• Per thousand requests: $3.47

GPT-5-mini vs purpose-built extraction API

Plan	GPT-5-mini via OpenAI API	cloro cost (5 credits × CPM)	Difference
Hobby (250K requests)	$868	$500 (5 × $0.40)	$368
Business (3.3M requests)	$11,451	$4,950 (5 × $0.30)	$6,501

Per-thousand: $3.47 (GPT-5-mini) vs $2.00 (cloro Hobby) vs $1.50 (cloro Business). The gap is narrower than against full GPT-5 but still meaningful at sustained volume.

Summary: models compared

Model	Cost per 1K requests	vs purpose-built extraction API
GPT-5	$17.34	88.5% more expensive (vs $2.00)
GPT-5-mini	$3.47	42.3% more expensive (vs $2.00)
Extraction API (cloro)	$2.00	—

Real-world impact at scale

Translating these per-request numbers into operational cost at the volumes a brand-monitoring program actually runs at:

Scenario: monitoring 1,000 brands with 100 daily queries each

• Daily queries: 100,000
• Monthly queries: 3,000,000

Monthly cost

• GPT-5 via OpenAI API: $52,020
• GPT-5-mini via OpenAI API: $10,410
• Purpose-built extraction API (cloro Business): $4,500

Annual difference vs the extraction API

• vs GPT-5: $570,240
• vs GPT-5-mini: $70,920

The break-even point at which the LLM-as-extractor pattern stops making economic sense lands earlier than most teams expect. Below 100K queries the cost difference is rounding error and the LLM’s flexibility wins. Past 1M/month and the system-prompt tax dominates the bill, at which point a purpose-built extractor is the rational call.

For deeper pricing comparisons across the broader extraction-API market, see Cheapest SERP APIs in 2026 and Best SERP APIs.

Current GPT-5 API pricing (2026 update)

The benchmark above uses the GPT-5 launch prices from October 2025. The lineup has changed since. Plain gpt-5 and gpt-5-mini have been retired.

As of July 2026, OpenAI’s published API pricing lists the GPT-5.4 and GPT-5.5 families instead. If you are searching for GPT-5 API pricing per million tokens today, these are the current standard rates.

Model	Input / 1M	Cached input / 1M	Output / 1M
gpt-5.5	$5.00	$0.50	$30.00
gpt-5.5-pro	$30.00	—	$180.00
gpt-5.4	$2.50	$0.25	$15.00
gpt-5.4-mini	$0.75	$0.075	$4.50
gpt-5.4-nano	$0.20	$0.02	$1.25

A few things stand out. The flagship gpt-5.4 costs twice the old GPT-5 input rate. Output climbed from $10 to $15 per 1M. The gpt-5.4-mini tier replaced gpt-5-mini, but at a higher price.

So the cost gap this GPT-5 API cost analysis found has widened, not closed. A structured-extraction workload on the current flagship costs more than the October 2025 numbers suggest, and re-running the same 10,000-query test today would land above $17.34 per 1,000 requests.

How per-token pricing actually works

OpenAI quotes prices per one million tokens, not per single token. A token is a chunk of text, roughly four characters of English. So 1M tokens is roughly 750,000 words.

To get cost per 1,000 tokens, divide the per-1M price by 1,000. On gpt-5.4, that is $0.0025 per 1K input tokens and $0.015 per 1K output tokens.

Two rules explain most of the bill. Output tokens cost far more than input tokens. And you pay for both the prompt you send and the completion you get back.

In our test, output was 4.75x the input volume. That is why output pricing, not the cheap headline input rate, drove the total.

The mini and nano tiers

Not every workload needs the flagship. The gpt-5.4-mini tier trades some reasoning depth for a much lower price. It runs $0.75 input and $4.50 output per 1M.

The gpt-5.4-nano tier goes cheaper still, at $0.20 input and $1.25 output per 1M. For high-volume, low-complexity extraction, nano can cut the model bill by an order of magnitude versus the flagship.

The trade-off is quality. Nano is weaker at strict schema adherence and long structured answers, so it is a poor fit for the citation-heavy JSON this test demanded.

How to cut the GPT-5 API bill

The system-prompt tax is not fixed in stone. Two OpenAI features — prompt caching and the Batch API — attack it directly. A purpose-built extractor removes it entirely.

Prompt caching for the repeated system prompt

Our 382-token system prompt is identical on every call, which looks tailor-made for prompt caching. On gpt-5.4, cached input is billed at $0.25 per 1M versus $2.50 standard — a 10x reduction, applied automatically with no code changes.

One caveat matters at this scale. OpenAI only caches prompts of 1,024 tokens or more, and our average input is 463 tokens — below that floor. A schema prompt this compact never triggers the cache.

Teams whose instructions run past 1,024 tokens are the real winners here: OpenAI says caching can cut input token costs “by up to 90%” for free. For a short prompt like ours, the lever to pull is batching or a dedicated API, not caching.

Caching also does not touch output tokens. And output is where this workload spends most of its money. So even when it applies, caching trims the input overhead but does not close the gap with a dedicated API.

Batch API for non-urgent jobs

Brand monitoring rarely needs a response in the same second. That makes it a good fit for OpenAI’s Batch API, which runs jobs asynchronously and returns them within a 24-hour window.

In exchange, OpenAI applies a 50% cost discount compared to synchronous requests. On gpt-5.4, batch pricing is $1.25 input and $7.50 output per 1M. Combined with prompt caching where it applies, batch can roughly halve the effective cost of a large extraction run. It still does not beat a flat per-request extraction credit at scale, but it narrows the distance.

Or skip the tax entirely

A purpose-built SERP extraction API ships the structured-output guarantee inside the product. There is no schema prompt to send on every call. There is no output-token bill for reformatting the same JSON shape 10,000 times.

cloro charges a flat credit per structured search. That is why its per-thousand cost stays near $2.00 no matter how verbose each answer is.

How to run your own GPT-5 API cost analysis

Numbers move as OpenAI updates the lineup, so the durable skill is the method, not the snapshot. A repeatable GPT-5 API cost analysis has four steps.

• Measure real token counts. Send a representative sample through the API and read the actual input and output token usage, rather than estimating from character counts.
• Separate fixed from variable input. The system prompt is fixed on every call while the user query varies, so knowing the split tells you whether caching or batching can help.
• Weight by output. Output tokens cost several times more than input, so verbose answers dominate the bill — price the completion, not just the prompt.
• Model at your real volume. A gap that is rounding error at 100K queries a month becomes a six-figure line item at 3M.

Run those four steps against current rates and you get a defensible GPT-5 API cost figure instead of a headline guess.

When GPT-5 beats a purpose-built API — and when it doesn’t

The right tool depends almost entirely on volume and flexibility needs.

GPT-5 wins when:

• Volume is under ~100K queries per month — the cost gap is rounding error at that scale.
• Your schema changes often. An LLM adapts to a new prompt instantly.
• You need reasoning, not just extraction — summaries, judgments, or open-ended answers.

A purpose-built extractor wins when:

• Volume is sustained above ~1M queries per month, and the system-prompt tax compounds.
• The output shape is stable — you are paying an LLM to reformat the same JSON over and over.
• Latency and cost predictability matter. A flat per-request credit is easier to forecast than token counts.

For most brand-monitoring programs the crossover lands earlier than teams expect. The moment structured extraction becomes a steady, high-volume pipeline, the token math stops favoring a general-purpose model.

---

Methodology note: tests were conducted using real-world brand-monitoring queries. Costs are based on OpenAI’s published API pricing as of October 2025; cloro pricing reflects the public Hobby and Business plans. Your actual costs may vary based on specific query complexity, output verbosity, and negotiated enterprise pricing.