OpenAI API pricing for GPT-4.1, GPT-4o, o1, o3-mini, and DALL·E

OpenAI’s pricing surface is broader than Anthropic’s — chat models, reasoning models with hidden output tokens, image generation through DALL·E, embeddings, and an audio API. The published rates live at openai.com/api/pricing, split per million tokens for LLMs, per image for DALL·E, and per character or minute for audio. The trap for solo founders is treating “OpenAI API” as one cost line. In practice you’re budgeting four or five different meters, and the o-series reasoning models generate hidden tokens that don’t show up in your prompt but very much show up on the bill.

TL;DR

• Three families, not one. GPT-4.1 / 4.1-mini for general-purpose chat, GPT-4o / 4o-mini for multimodal, o1 / o3-mini for reasoning. Each has its own price point and use case.
• Cached input is roughly 50% off on most models — less aggressive than Anthropic’s 90% but it kicks in automatically when you reuse prompts.
• Reasoning models burn hidden output tokens. o1 and o3-mini generate internal reasoning that you don’t see but you do pay for. Budget 2–5× what you’d expect from a similar non-reasoning prompt.
• Batch API is 50% off, 24-hour SLA. Stack it with cached input for the cheapest async work in the lineup.
• Embeddings are cheap. $0.02–$0.13 per million tokens. Don’t over-engineer to avoid them.
• DALL·E is per-image, not per-token. Standard 1024×1024 around $0.04, HD around $0.08. Easy to budget once you know the per-image rate.

The 2026 model lineup at a glance

OpenAI ships in three pricing families that map to three jobs.

The headline cheat-sheet:

• 4o-mini is the cheapest serious model in the lineup at $0.15 / $0.60. For straightforward chat or classification, this is your default.
• 4.1 sits in the productive middle at $2 / $8 — smart enough for most agent and tool-use workloads at a fraction of o1’s cost.
• o1 is the premium reasoning tier at $15 / $60 — pricier than Anthropic’s Opus on output and noticeably more expensive than 4.1 on every dimension. Reserve it for genuinely hard reasoning.
• o1-mini and o3-mini are reasoning-on-a-budget at the same $1.10 / $4.40 price point, sitting between the GPT-4 family and full o1.

Input vs output tokens — same asymmetry, slightly tighter ratio

OpenAI prices output at 4× input on most models, slightly tighter than Anthropic’s 5× ratio but conceptually identical. The same advice applies: model your costs by direction, instruct your prompts to be terse where you can, and set max_tokens defensively.

One subtlety on the o-series: the output cost includes reasoning tokens the model generates internally and never shows you. A simple math problem might use 500 visible output tokens and another 2,000 reasoning tokens. You pay for all 2,500. For an o1 prompt with 500 visible output and 2,000 hidden reasoning tokens, you pay 2,500 × $60/MTok = $0.15 per call — not the $0.03 you’d estimate from visible output alone.

Cached input — automatic, modest discount

OpenAI’s prompt caching kicks in automatically when you send a prompt with a prefix that matches a recently-seen prompt. Cached portions get billed at roughly 50% of standard input rate — less aggressive than Anthropic’s 90% discount, but it requires no API changes and applies retroactively to repeated prefixes.

What this means in practice:

• Long, stable system prompts get cheaper for free. If your system prompt is 3,000 tokens and most of it doesn’t change between calls, you save half the input cost on subsequent requests.
• The cache window is short. Cached prefixes are evicted after a period of inactivity, so a low-traffic app gets less benefit than a busy one.
• You can’t explicitly mark cache breakpoints the way you can on Anthropic. The cache works on prefix match, period — reorder your prompt so stable content comes first.
• The discount stacks with Batch. A cached prompt sent through Batch is half off twice (effectively 25% of headline rate on the cached portion).

Reasoning models — o1, o3, and the hidden-token tax

The o-series handles problems where deeper internal computation produces better answers — competitive math, multi-step logic, complex code refactoring, tricky planning. The price for that depth is twofold: a higher per-token output rate (o1 at $60/MTok) and higher token consumption per problem because the model produces internal reasoning chains.

Practical pattern: never call o1 from a user-facing latency-sensitive path. Reasoning calls take seconds to tens of seconds and cost an order of magnitude more than 4.1 calls. The right architecture is a router: send each request to 4o-mini or 4.1-mini first, and escalate to o1 or o3-mini only when the simpler model flags low confidence. The cheaper reasoning options (o1-mini, o3-mini) at $1.10 / $4.40 give you reasoning behavior at a fraction of o1’s price — for many workloads they’re the sweet spot.

Vision pricing — image tokens with detail levels

OpenAI charges for image inputs through the same input-token meter, with a twist: you can specify detail: "low" for a flat ~85-token cost per image, or detail: "high" which tiles the image and bills based on tile count (roughly 170 tokens per 512×512 tile plus a base).

The split matters:

• Low detail — cheap, fixed cost, suitable for “is this a cat”-level questions and rough scene descriptions.
• High detail — necessary for OCR, document parsing, fine visual analysis. A typical 1024×1024 image runs roughly 765 tokens at high detail.

For a vision-heavy product (receipts, invoices, screenshot QA), high detail is non-negotiable. On 4o, a high-detail 1024×1024 image costs about $0.002. Across thousands of users that’s a meaningful line item but rarely a dominant one.

Embeddings — cheap and important

OpenAI’s embedding models price per million input tokens with no separate output meter (embeddings produce a fixed vector, not generated text):

• text-embedding-3-small — $0.02 per million tokens. Default choice for most retrieval workloads.
• text-embedding-3-large — $0.13 per million tokens. Higher dimensional output, slightly better retrieval quality.

To put this in context: indexing a 100,000-page knowledge base at ~500 tokens per page is 50M tokens. On the small model that’s $1. On the large model, $6.50. Embeddings are the cheapest line item in the entire OpenAI bill for most products. Don’t over-engineer to avoid them.

DALL·E pricing — per image, by size and quality

Image generation is priced per image, with rates that depend on resolution and quality tier:

For a SaaS shipping generated thumbnails, marketing imagery, or AI avatars, this is the budget driver. At $0.04 per image, a product generating 100,000 images/month spends $4,000 on DALL·E alone. Cache aggressively, dedupe by prompt hash, and stick with standard resolution unless HD is genuinely required.

Batch API — 50% off for async work

Same playbook as Anthropic’s Batch API: submit jobs, OpenAI returns results within 24 hours, and you pay 50% of the standard rate on both input and output. The discount stacks with cached input. For nightly digests, bulk SEO meta generation, review classification, embedding refresh, or evaluation runs over historical traffic, Batch is a no-brainer. It doesn’t fit anything user-facing or workflows that depend on a prior call’s output.

Realistic monthly bills for solo SaaS

Three personas, all running on GPT-4.1-mini (the equivalent default workhorse), with cached input enabled. The math mirrors our Anthropic API pricing breakdown so you can compare side by side.

The margin math at $20/month

Same framing as the Anthropic page. At $20/month, after Stripe fees of ~$0.90, hosting at ~$1, and a 50% gross margin target, you have roughly $8 of API budget per paying user per month.

What that buys you on GPT-4.1 (output at $8/MTok):

• $8 of output = 1M output tokens. At 200 tokens/reply, that’s ~5,000 messages/month per user. Generous.
• $8 of output at 1K tokens/generation = 1,000 generations/month. Plenty for content tools.
• $8 of output at 2K tokens/code-gen = 500 generations/month. Comfortable for most code-gen products.

On 4.1-mini (output at $1.60/MTok), each line above gets 5× more headroom — chatbots become trivially profitable. On o1 (output at $60/MTok), $8 buys you only ~133K output tokens, or roughly 25 reasoning calls at 5K tokens each. Reasoning models are not a paid-tier’s default; they’re a premium-tier escape hatch.

Rate limits and the tier system

OpenAI gates capacity through five usage tiers tied to a combination of cumulative spend and time since first payment. New developers start in Tier 1 with low requests-per-minute and tokens-per-minute caps. As you spend and time passes, you graduate:

• Tier 1 — entry tier. Modest RPM/TPM caps, usable for prototyping. Reached after the first paid usage.
• Tier 2 — unlocked after a small cumulative spend and a waiting period. Caps roughly double.
• Tier 3 — meaningfully higher capacity, sufficient for early production traffic.
• Tier 4 — high-throughput production limits, suitable for most solo SaaS at scale.
• Tier 5 — reached after substantial sustained spend; near-uncapped for most practical purposes.

The exact thresholds shift over time and are documented on openai.com/api/pricing and in the rate-limit docs. For solo founders, the practical implication: budget time at the start of a launch to climb tiers if you expect spiky traffic. Submit a tier-upgrade request through the dashboard if you have predictable demand.

When OpenAI is the right pick vs Claude

Both providers ship excellent models at competitive prices. The choice comes down to four questions.

• Latency. 4o and 4o-mini have the lowest first-token latency in the OpenAI lineup, often beating Anthropic’s Sonnet meaningfully. For voice agents and real-time chat, this is a real edge.
• Multimodal breadth. OpenAI ships image generation, audio in/out, and vision in one API. Anthropic offers vision but no image generation or audio.
• Reasoning depth. The o-series excels at math and rigorous logical reasoning. For workloads that need chain-of-thought reasoning, o1 or o3-mini is often the right call — just budget for hidden tokens.
• Coding and writing nuance. Anthropic’s Sonnet and Opus consistently rate well for long-form writing, code generation, and nuanced instructions. For agent-style workloads with tool use over many turns, Claude is many founders’ default.

The pragmatic answer is “use both.” Wire your code through a thin abstraction so you can route workloads to whichever provider serves the use case best. Our best AI tools for solo SaaS founders roundup covers the broader landscape, and the Anthropic API pricing breakdown sits alongside this page for direct comparison.

Bottom line

Default to GPT-4.1-mini for general workloads, 4o-mini for cost-sensitive multimodal, and 4.1 when quality matters. Reserve o1 / o3-mini for genuinely hard reasoning and route to them via a confidence-threshold pattern, not by default. Turn on cached input by structuring prompts with stable content first, run async work through Batch for the 50% discount, and watch the o-series hidden-token math carefully.

The OpenAI bill is rarely one line; it’s four or five meters running in parallel. Modeling each independently — chat, embeddings, vision, DALL·E, audio — is the difference between a product that hits margin and one that doesn’t. The AI token cost calculator helps you build a per-user cost model, and our true cost of running an AI SaaS deep-dive covers the full unit-economics framework.

Related reading

• AI token cost calculator — per-call cost across providers
• Anthropic API pricing explained
• How to build an AI chatbot SaaS with Claude
• Best AI tools for solo SaaS founders
• The true cost of running an AI SaaS