OpenAI APIdevelopers.openai.com ↗
Retrieve current OpenAI model pricing across all tiers and categories via one API endpoint. Filter by section or tier to compare GPT, image, audio, and video costs.
What is the OpenAI API?
The OpenAI Pricing API exposes one endpoint, get_pricing, that returns per-token and per-unit costs for every model listed on the OpenAI developer pricing page, covering nine sections and four pricing tiers. Each response object includes the model name, section (e.g., Flagship models, Multimodal models, Image generation), pricing tier (Standard, Batch, Flex, or Priority), and the corresponding input/output cost fields. Use the section and tier query parameters to narrow results to exactly the models you need.
curl -X GET 'https://api.parse.bot/scraper/2801fee9-9543-4a70-9ab5-e01bc965c803/get_pricing?tier=Standard§ion=Flagship' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace developers-openai-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: OpenAI Model Pricing SDK — retrieve and filter model pricing data."""
from parse_apis.openai_model_pricing_api import OpenAIPricing, Section, Tier, PricingUnavailable
client = OpenAIPricing()
# List all flagship models at Standard tier — limit caps total items fetched.
for model in client.modelpricings.list(section=Section.FLAGSHIP, tier=Tier.STANDARD, limit=5):
print(model.model, model.input, model.output)
# Drill into a specific section — take one item with .first().
first_tool = client.modelpricings.list(section=Section.TOOLS, limit=1).first()
if first_tool:
print(first_tool.section, first_tool.tier, first_tool.model)
# Typed error handling around a pricing call.
try:
for m in client.modelpricings.list(section=Section.FINETUNING, tier=Tier.BATCH, limit=3):
print(m.model, m.cached_input, m.output)
except PricingUnavailable as exc:
print(f"Pricing unavailable: {exc}")
print("exercised: modelpricings.list with Section/Tier enums, .first(), error handling")
Get all OpenAI model pricing. Returns each model with its section, pricing tier, and per-token costs. Optionally filter by section name or pricing tier using case-insensitive partial matching. Pricing fields vary by section: text models have input/output/cached_input; image models have modality-based pricing; video models have price_per_second; tools have flat per-call or per-GB pricing. Returns a single page of all matching models.
| Param | Type | Description |
|---|---|---|
| tier | string | Filter by pricing tier (case-insensitive partial match). Some sections only have a subset of tiers. |
| section | string | Filter by section name (case-insensitive partial match). Partial matches work, e.g. 'image' matches 'Image generation models'. |
{
"type": "object",
"fields": {
"total": "integer count of models returned",
"models": "array of model pricing objects, each containing section, tier, model name, and pricing fields that vary by section (e.g. input, output, cached_input for text models; modality, price_per_second for video/image models)"
},
"sample": {
"data": {
"total": 67,
"models": [
{
"tier": "Standard",
"input": "$10.00",
"model": "gpt-5.5",
"output": "$45.00",
"model_2": "$30.00",
"section": "Flagship models",
"cached_input": "$1.00",
"long_context": "$0.50",
"short_context": "$5.00"
},
{
"tier": "Standard",
"input": "$5.00",
"model": "gpt-5.4",
"output": "$22.50",
"model_2": "$15.00",
"section": "Flagship models",
"cached_input": "$0.50",
"long_context": "$0.25",
"short_context": "$2.50"
}
]
},
"status": "success"
}
}About the OpenAI API
What get_pricing Returns
The get_pricing endpoint returns an array of model pricing objects under the models key, along with a total count of matched results. Each object carries at minimum: the model name, the section it belongs to (e.g., "Flagship models", "Image generation", "Realtime and audio generation", "Transcription", "Tools", "Specialized", "Finetuning"), and the tier ("Standard", "Batch", "Flex", or "Priority"). Cost fields vary by section — text models include input and output per-token rates, while image and video generation models include unit-based pricing fields appropriate to their output type.
Filtering Options
Both the section and tier parameters accept case-insensitive partial strings, so passing tier=batch matches the "Batch" tier across all sections, and passing section=flagship returns only Flagship model entries. Combining both parameters narrows results to the intersection — for example, Batch-tier pricing for Flagship models only. When neither parameter is supplied, the full catalog is returned. The total field in the response reflects the count after filtering.
Coverage Scope
The API reflects the nine model groupings published on developers.openai.com/api/docs/pricing: Flagship, Multimodal, Image generation, Video generation, Realtime and audio generation, Transcription, Tools, Specialized, and Finetuning. This covers the GPT-4 family, o-series reasoning models, DALL-E and image variants, Whisper-based transcription, embeddings, moderation, and fine-tuned model cost structures. Pricing fields are sourced directly from the published pricing table, so they change when OpenAI updates that page.
The OpenAI API is a managed, monitored endpoint for developers.openai.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when developers.openai.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official developers.openai.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Monitoring OpenAI pricing changes over time and alerting when costs shift for a specific model
- Comparing Batch-tier vs Standard-tier costs across all Flagship models before choosing a processing strategy
- Building a cost estimator that looks up current input/output token rates for a given model by name
- Selecting the lowest-cost model for a task by comparing per-token rates across sections
- Populating an internal rate card or billing dashboard with up-to-date OpenAI model costs
- Filtering to Image generation or Video generation sections to plan budget for media-generation pipelines
- Tracking Finetuning tier pricing separately to estimate custom model training and inference costs
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does OpenAI have an official developer API for pricing data?+
What pricing fields does a model object include, and do they differ by section?+
section, tier, and model name fields. Cost fields vary by section: text-based models (Flagship, Specialized, Finetuning) include input and output per-token rates. Image generation and video generation models carry unit-appropriate pricing fields for those output types. Transcription and audio models follow their own cost-per-unit structure. The response shape adapts to the type of model in each section.How fresh is the pricing data returned by the API?+
Can I retrieve pricing for a specific model by its exact name?+
get_pricing endpoint supports partial, case-insensitive filtering only via the section and tier parameters, not by model name directly. To find a specific model, fetch the full list (or filter by section) and match the model field client-side. The API does not currently expose a model-name filter parameter. You can fork it on Parse and revise to add a model-name filter endpoint.