ChatGPT Pro API Credits: Claim Up to $500 a Month (2026)

Since this was written, OpenRouter's model feed lists GPT-5.4 Mini in place of GPT-4.1 mini, GPT-4o mini and gpt-5-mini; Gemini 4 Carbon in place of gemini-2.5-pro.

How to claim the monthly OpenAI API credit that now comes with ChatGPT Pro and Business, what it pays for, the traps around Codex and usage tiers, and how to turn it into a live product before it expires

Since October 28, a ChatGPT Pro subscription pays its own price back as API money: up to $500 a month.

That day OpenAI's changelog announced that eligible ChatGPT Pro and Business subscribers can claim free API credits by linking an API organization they own - OpenAI changelog. The amounts follow the plan: $100, $200 or $500 a month on the three Pro tiers, and $20 per paid Standard seat or $100 per paid Premium seat on Business, pooled and capped at $500 per workspace - OpenAI API docs. The money lands in an OpenAI API organization, where it pays for the Responses, Agents, Decisions, GPT-Live, Realtime and Images APIs and their built-in tools, with no payment method required. Anthropic already runs the same kind of monthly credit for its Max, Ultra and Team plans - Claude Help Center. So two of the three largest labs now hand their most expensive subscribers a monthly budget to build with.

Most of that money will expire unused unless you build something that calls the API. OpenAI is explicit that Codex usage through API keys is not covered, and that the credits do not raise any ChatGPT or signed-in Codex usage limit - OpenAI. Many people pay for Pro because of Codex, which is precisely the product the credit leaves alone. Unused credit disappears at the end of every billing cycle, the receiving organization can only be changed through support, and an organization that has never bought credits may sit on a usage tier whose monthly limit is lower than a large grant. To get value out of it, you need a product or a pipeline that spends it, and you need that product built so a leaked key or a runaway agent cannot spend past the grant into money you actually pay.

This guide covers how to claim the credit on both paths, exactly what it pays for and the traps around Codex and usage tiers, what $100, $200 and $500 buy on each current OpenAI model, how to stretch it with batch, flex, caching and the effort setting, the guardrails to set before a key goes into production, a reference build that ships a real product on the credit, the agent options (including the Agent Builder shutdown on November 30), how it compares with Anthropic's and Google's subscriber credits, and what goes wrong when it runs out. Every price and rule below was checked against OpenAI's developer documentation and the other primary pages cited inline on November 6, 2026.

Contents

1. What OpenAI Shipped on October 28
2. Why a Subscription Now Pays Out in API Credit
3. Who Qualifies, and the Fine Print That Decides It
4. How to Claim the Credit, Step by Step
5. What the Credit Covers, and What It Never Will
6. What $100, $200 and $500 Actually Buy
7. Which OpenAI Model to Spend It On
8. Make the Credit Last: Batch, Flex, Caching and Effort
9. Guardrails First: Projects, Keys and Spend Limits
10. A Reference Build: Shipping a Product on the Credit
11. Agents on the Credit, and the Agent Builder Shutdown
12. Pro, Business, Claude or Google: Which Credit Is Worth Most
13. When the Credit Runs Out: Failure Modes and Deadlines
14. Routes From Idea to Live Product, and Where the Credit Fits
15. A Decision Framework

Where the Credit Can Go, Scored

Before the detail, it helps to see every place a subscriber might try to spend the credit side by side, including the places it cannot go. The table scores ten surfaces on the four things that decide whether the money becomes something useful: whether the credit pays for the surface at all, how much useful work each dollar buys, how fast you get from nothing to a first working result, and how well the surface holds up once real users depend on it. Each cell carries its score and the fact behind it, and the sections below explain every row.

The weighting reflects a plain priority. A surface the credit does not pay for is worth little for this purpose however good it is, so coverage carries 30%. Cost per outcome and production fit carry 25% each, because a credit that is gone in a week and a prototype nobody can use both waste the month. Time to first result carries 20%, because the credit expires each cycle and a slow start burns part of it. Scores run from 0 (absent or unusable) to 10 (the best available here), and the final column is the weighted average.

The pattern is the point of the table. Everything that ends in your own product calling the API scores high, because that is the only place the credit was designed to land. The two Codex rows score low for opposite reasons: signed in with ChatGPT, Codex runs on plan limits the credit never touches, and with an API key it is excluded by name. Sources for each cell appear in the sections below.

1. What OpenAI Shipped on October 28

The benefit itself is simple to state. Eligible ChatGPT Pro and Business subscriptions can claim free API credits as part of their subscription, activate once by linking the subscription to an API organization they own, and then receive credits automatically at each renewal "while these benefits are available and your subscription is eligible" - OpenAI API docs. Unused credits expire at the end of the billing cycle and do not roll over, and no API payment method is needed to spend them. The OpenAI Developers account announced it the same day: "Starting today, eligible ChatGPT Pro and Business subscribers can claim up to $500 per month in API credits to build apps and agents" - OpenAI Developers on X.

The amounts, exactly as OpenAI lists them:

Two details in that table carry more weight than they look. First, your first grant is prorated for the time left in your current billing cycle and expires at the end of that cycle, so claiming two days before a renewal yields a small first grant and the full amount arrives with the next payment. Second, a Business workspace that pays annually upfront receives the whole year's grant in one issuance, and that grant expires at the end of the annual cycle - OpenAI. That turns a monthly allowance into a yearly budget of up to $6,000 that can be spent in bursts, which suits a team that builds in sprints rather than evenly.

OpenAI published a short video with the announcement on its main YouTube channel, posted the same afternoon. It is the official walk-through of the benefit and runs about two and a half minutes:

The video's description repeats the same amounts as the documentation (Pro by tier at $100, $200 or $500; Business at $20 per Standard seat and $100 per Premium seat, pooled to $500) and links to OpenAI's help center article on the benefit, so the documentation and the launch video agree.

The plans behind the numbers

The Pro plan itself has changed shape this year. OpenAI added a $100 Pro tier on April 9, positioned for daily Codex users with five times the Codex usage of Plus, alongside the existing $200 plan - TechCrunch. Today Pro is sold at $100, $200 or $500 a month, and only the $500 tier includes Ultrafast mode in Codex - OpenAI Codex pricing. Business costs $20 per user per month billed annually or $25 billed monthly, with a two-user minimum, on the same page. The Premium seat, launched in August, is listed at $100 per user per month annually or $125 monthly, with five times Standard's included usage and no five-hour limit - Elephas.

Put those prices next to the grants and a design choice appears. Every grant equals the plan's cheapest price: Pro 100 returns $100, Pro 200 returns $200, Pro 500 returns $500, an annual Standard seat at $20 returns $20 and an annual Premium seat at $100 returns $100. A Business seat billed monthly costs $5 or $25 more than it returns. The chart below sets the price of each plan against the credit it carries.

The same weeks on the API platform

The credit arrived in a dense month for OpenAI's developer platform, and several of those releases change what the money is best spent on. On October 26, OpenAI released GPT-6.1 Terra, a fast, efficient model for visual reasoning, computer use and natural writing; on October 22, the Decisions API became generally available with prompt-cache discounts and up to 400 questions per request; on October 20, a 12-hour prompt caching option arrived; and on November 4, two image models, GPT Image 2.6 Sunburst and Flare, shipped with SVG and animated GIF output - OpenAI changelog. GPT-6.1 Terra is priced at $1 per million input tokens and $5 per million output tokens, which makes it the natural default for much of what a credit-funded product does. Earlier in October the platform also cut its usage tiers from five to three (Build, Launch and Grow), a change that matters for anyone holding a large grant on a new organization, as section 5 explains.

2. Why a Subscription Now Pays Out in API Credit

The interesting question is not what OpenAI is giving away but why a subscription company would hand subscribers metered API money at all. The answer starts with the two ways OpenAI sells intelligence and how differently they behave.

A subscription is a flat fee for use of OpenAI's own apps, ChatGPT and Codex, bounded by usage limits OpenAI sets and can change. The subscriber's cost is fixed, and OpenAI's cost rises with how hard the subscriber works the product, which is why the limits exist and why they keep being revised. The API is the opposite: every token is metered at a published rate, the developer's cost rises with use, and OpenAI's revenue rises with it. One business is priced on access, the other on consumption. The credit is a bridge between them: it converts part of a fixed subscription payment into consumption capacity, and it puts that capacity exactly where OpenAI's platform wants developers to be, inside products that call the API.

Why the economics work for OpenAI

Three properties make this cheaper for OpenAI than a $500 headline suggests. First, a credit is denominated at list price, while what it costs OpenAI to honor is the cost of serving those tokens, so a dollar of credit used is not a dollar of cost. Second, unused credit expires each cycle, and a large share of subscribers who never build anything will never spend theirs; that breakage is a known feature of every expiring credit program. Third, the subscribers who do spend it are the ones most likely to keep building, and a product that runs on OpenAI's API at $200 a month of free credit tends to keep running on it at $2,000 a month of paid usage once it has customers. The credit is customer acquisition for the API platform, aimed at the people already paying the most for OpenAI's apps.

The timing also fits a broader repricing of subscriptions around agentic use. On October 29, after a backlash over a planned cut to the usage included in Pro 200, OpenAI announced the opposite on X: "We are doubling all usage limits for all Pro 100/200/500 tiers and Business Premium, effective today" - BleepingComputer. Subscriptions are being shaped around how much agentic work people do in ChatGPT and Codex, and the API credit is a separate lever that rewards a different behavior: building your own software on the platform.

Why it matters that every lab now does it

OpenAI is not first. Anthropic introduced a comparable monthly credit for its Max and Team subscribers in early October - DataNorth. Its help center now lists $100 on Max, $200 on Ultra, and $20 or $100 per Team seat pooled to $500 - Claude Help Center. Google moved earlier still, folding its developer program into Google AI Pro and Ultra on January 27 with $10 a month in Google Cloud credits for Pro and $100 a month for Ultra, usable toward the Gemini API, Vertex AI and Cloud Run - Google. Three labs converging on the same structure within a year suggests a new norm: a premium AI subscription now carries an allowance to build with that lab's models, not only to use its apps.

For a builder, the structural consequence is that the cost of starting an AI product on a lab you already pay for has fallen to zero. A subscriber can prototype, launch, and run the first months of a small product's AI entirely on the grant. What has not changed is the cost of scaling: once real usage passes the grant, every token is metered again. So the right way to think about the credit is as a monthly research and launch budget with a hard use-it-or-lose-it constraint, worth what you would have spent on the API anyway plus the value of whatever it lets you ship that you otherwise would not.

The other side of the same strategy

The credit pays for AI your product uses on your behalf. OpenAI is building the mirror image too: Sign in with ChatGPT, which lets a website, plugin or open-source client run requests on the user's own ChatGPT plan - OpenAI. Put together, the two make a coherent platform play: the subscriber's grant funds the build and the early runtime, and the user's plan can fund the runtime later. We covered the second half in depth in our guide to Sign in with ChatGPT and letting users cover your AI bill.

3. Who Qualifies, and the Fine Print That Decides It

Eligibility comes down to three conditions, and nearly every failed claim reported so far traces back to one of them. To claim the benefit you need an active, paid ChatGPT Pro or Business subscription at least seven days old (free trials and complimentary subscriptions do not qualify), you must be an owner of both the ChatGPT subscription or Business workspace and the API organization that receives the credits, and you must use the same email address for your ChatGPT account and the API account that links the organization - OpenAI API docs.

The ownership rule is the one that surprises teams. In a Business workspace, being a member or even an admin is not enough; the person claiming must own the workspace and own the API organization. In a company where one person holds the ChatGPT Business subscription and an engineer created the API organization years ago under a different email, neither of them can claim until ownership and email line up. Sort that out before you open the claim flow, because the receiving organization cannot be swapped later without contacting support.

Plans that do not qualify

The documentation names Pro and Business as the eligible plans. It also states what happens on the way out: if you downgrade to an ineligible plan "such as Plus, Go, or Free," your API organization link is removed at the end of the billing cycle, and a Business workspace that moves to ChatGPT Enterprise loses its link the same way, because Enterprise is not eligible for this benefit - OpenAI. Plus subscribers, who pay $20 a month, therefore get no credit at all - OpenAI Codex pricing. The cheapest route into the benefit is the $100 Pro tier or a Business workspace.

Subscriptions bought through the App Store or Google Play

OpenAI's documentation does not address mobile billing, and this is where most reports of trouble cluster. In the developer community thread under the official announcement, several Pro subscribers billed through Google Play described seeing no claim option on either billing page despite being past seven days, owning the organization and using the same email, and an Apple App Store subscriber described a renewal that cancelled an earlier small grant without issuing the new one; OpenAI support's quoted reply was that the case had been referred for review - OpenAI Developer Community. Anthropic, by contrast, states that its equivalent credit works for subscriptions bought on the web, iOS or Android, with the claim made on the web. If your Pro plan is billed through a mobile store and the claim never appears, the honest expectation today is a support ticket, not a setting you have missed.

What happens when your plan changes

OpenAI documents the plan changes in detail, and they matter most for people who move between tiers or between Pro and Business. The table summarizes the rules from OpenAI's guide - OpenAI:

The practical lesson from this table is about timing. Because the first grant is prorated and later grants arrive with renewals, an upgrade made late in a cycle buys little credit for that cycle, and a move from Pro to Business costs at least a week without any credit. If you plan to change plans, do it at the start of a cycle, and claim on the new plan as soon as the seven days have passed.

4. How to Claim the Credit, Step by Step

There are two doors to the same benefit, one in ChatGPT and one in the API platform. Both link the same subscription to the same organization, so use whichever account you are already signed into, but sign into both with the email address the subscription is under.

Starting from ChatGPT:

1. Sign in to ChatGPT with the account that owns the eligible subscription.
2. For Pro, open Settings, then Billing. For Business, open the workspace's billing settings in ChatGPT or the Admin Console.
3. Find the API credits benefit and start the claim flow.
4. Review the API organization that will receive the credits, and pick the right one if you own several.
5. Confirm to activate the benefit.

Starting from the API platform:

1. Sign in to the OpenAI API platform with the email associated with your eligible subscription.
2. Select the API organization you own that should receive the credits.
3. Open Billing and find the API credit benefit.
4. Select the eligible subscription or Business workspace to link.
5. Confirm to activate the benefit.

Both sequences come straight from OpenAI's guide, which adds that someone new to the API can link the subscription to their Personal API Organization - OpenAI API docs. After claiming, the balance appears in the API platform's billing overview. From there OpenAI points new users to the API quickstart, the Agents API, the Responses, Decisions and Audio playgrounds, the usage dashboard, and the OpenAI Developers plugin in ChatGPT, which can create API keys directly inside ChatGPT and build alongside ChatGPT Sites.

The whole chain, from subscription to a request that spends the credit, looks like this:

Choosing which organization receives the credit

Because changing the receiving organization takes a support ticket, this one choice deserves a minute of thought. If you already run production traffic in an organization with purchased credits, linking that organization means the grant is spent first, before your purchased balance, by every project and key in it, including a staging environment or a teammate's experiment. That is convenient if you want the grant to subsidize existing usage and risky if you want it fenced off for one new product. A separate organization dedicated to the credit gives a clean ceiling: when the grant is gone, requests stop, and nothing else is touched. For most solo builders the Personal organization is the right home; for a company with existing API spend, a new organization for experiments is usually cleaner.

What a first grant looks like

The proration is easy to misread as a bug. One Pro 200 subscriber in OpenAI's community thread reported receiving a $7 grant on October 29, one day before the subscription renewed on October 30, which is about what a $200 monthly grant prorated to a single remaining day should be - OpenAI Developer Community. The same thread shows the rough edges of a new benefit: one subscriber who was asked to create an organization they already owned found a "link organization" button appeared a day later, and another saw the renewal grant only after the API dashboard's limit reset, a couple of days after the subscription renewed. If the claim does not appear at first, check the four conditions (seven days, ownership on both sides, same email, a web or ChatGPT-billed subscription), wait a day, and then contact support.

5. What the Credit Covers, and What It Never Will

The coverage rule is short: the benefit pays for paid API platform usage billed to the linked organization. OpenAI lists the main surfaces as the Responses API for text, code and image understanding, the Agents API including OpenAI-hosted sandbox charges, the Decisions API, GPT-Live and the Realtime API for voice, the Images API for generation and editing, and built-in tools with their usage and storage charges, such as web search, file search and Code Interpreter, plus other APIs on the platform - OpenAI API docs. Requests have to use a project API key from the linked organization; the same key in a different organization draws on nothing.

The Codex exclusion, precisely

Two sentences in the guide decide how most Pro subscribers will experience the benefit: "Codex usage through API keys is not supported by this benefit. These API credits also don't increase your ChatGPT or signed-in Codex usage limits." The second half means the credit and your Codex allowance live in separate worlds. The first half closes the obvious workaround. Codex can sign in with an API key instead of a ChatGPT account, and when it does, OpenAI bills that usage "through your OpenAI Platform account at standard API rates" instead of the plan's included usage - OpenAI Codex docs. Since the benefit does not support that usage, pointing Codex at your credit-linked organization's key is a way to spend purchased credit (or hit an error), not a way to stretch the grant.

The same boundary applies to OpenAI models bought through clouds: OpenAI's pricing page notes that models on Amazon Bedrock and Microsoft Azure are billed through those services - OpenAI pricing. The credit lives on OpenAI's own API platform and nowhere else.

The order in which money is spent

The linked organization uses free credits before purchased credits. When the free balance runs out, requests continue on purchased credits if any remain; if nothing remains, they fail with HTTP 429 and the error code credit_balance_exhausted - OpenAI. OpenAI suggests adding paid credits or turning on Auto Recharge to avoid the interruption. Whether you want that depends on what the credit is for: for a hobby product, the 429 is a feature, a hard ceiling that costs nothing; for a product with paying users, an outage on the first of the month is not acceptable, and you will want a small purchased buffer and a spend limit (section 9).

The usage-tier trap for large grants

This is the detail most guides to the benefit miss. OpenAI assigns every API organization an approved monthly usage limit tied to its usage tier, separate from any spend limit you set. After the October reshuffle there are a Free tier and three paid tiers, and a tier is reached by total credit purchases: Free allows $100 of usage a month, Build (after $5 of purchases) allows $500, Launch (after $100) allows $5,000, and Grow (after $500) allows $200,000 - OpenAI rate limits. The table speaks of credit purchases; the documentation does not say whether a subscription grant counts as one.

Follow that through for a Pro 500 subscriber who links a brand-new Personal organization that has never bought anything. If that organization sits on the Free tier, its approved usage limit is $100 a month, a fifth of the grant, and requests past it would be refused with organization_usage_limit_exceeded, the code OpenAI's spend-limit guide lists for an OpenAI-assigned usage limit - OpenAI spend limits. The per-model rate-limit tables in the documentation also list only the three paid tiers. So before you plan around spending a $200 or $500 grant, open Settings, Organization, Limits for the linked organization and read the approved usage limit there. If it is lower than your grant, a one-time $5 purchase moves an organization to Build according to OpenAI's table, and that purchase is also spent only after the free grant is used up.

What the credit does not change about data

The credit changes who pays, not how your data is handled. API data has not been used to train OpenAI's models since March 1, 2023 unless you opt in, and abuse-monitoring logs, which can include prompts and responses, are retained for up to 30 days by default - OpenAI. Zero Data Retention and Modified Abuse Monitoring exist but require OpenAI's prior approval. For a product that handles customer data, those are the same terms you would have with purchased credits, and they belong in your privacy notice either way.

6. What $100, $200 and $500 Actually Buy

A credit is only as large as the work it pays for, and that depends almost entirely on which model you call and how many tokens each request uses. Here are OpenAI's four current general models at standard rates, with the prices rendered from their live records:

The batch discount and the positioning come from OpenAI's own pages - OpenAI pricing. All four models carry a context window of 1.05M tokens, with up to 128K output tokens on Terra.

Translating tokens into requests

Per-million prices are hard to feel, so take a concrete request: 2,000 input tokens (a system prompt, some context and a user message) and 500 output tokens (a few paragraphs of answer). At standard rates, 1,000 of those requests cost about $45 on Astra, $9 on Sol, $4.50 on Terra and $0.45 on Luna. So a $200 grant pays for roughly 4,400 such requests on Astra, 22,000 on Sol, 44,000 on Terra or 440,000 on Luna in a month, and the batch rate doubles each of those for work that can wait. The chart shows the per-thousand cost at standard and batch rates.

Two adjustments keep that estimate honest. The first is reasoning. All four models reason, and reasoning tokens, while invisible in the API response, occupy context and are billed as output tokens - OpenAI reasoning guide. A request that shows 500 tokens of answer can bill several thousand output tokens at medium effort on a hard prompt, which is why the effort setting in section 8 matters as much as the model choice. The second is long prompts. On Terra and Luna, prompts above 272K input tokens are priced at 2x the input and cache rates and 1.5x output for the whole request - OpenAI model page. A product that stuffs whole document sets into every call can double its cost without noticing.

The other meters on the bill

Text tokens are not the only charge the credit absorbs, and several of the other meters are where a grant disappears fastest. OpenAI's pricing page lists them - OpenAI pricing:

• Web search: $10 per 1,000 calls, plus the retrieved search content billed as input tokens at the model's rate.
• File search: $2.50 per 1,000 tool calls, and storage at $0.10 per GB per day after 1 GB free.
• Hosted Shell and Code Interpreter containers: from $0.03 per 20-minute session for 1 GB, up to $1.92 for 64 GB, billed by the minute with a five-minute minimum for eligible sessions.
• GPT-Live voice sessions: $0.05 per minute, billed per second, with the backend model and tools charged separately.
• Transcription: gpt-transcribe at about $0.0045 per minute.
• GPT Image 2.6 Sunburst and Flare: $8 per million image input tokens, $5 per million text input tokens and $30 per million image output tokens.

Those numbers convert into intuitive budgets. A $100 grant covers 2,000 minutes of GPT-Live session time before the backend model's tokens, or 10,000 web searches before their content tokens. The image line is the one to watch: OpenAI prices images by token rather than per picture, and says equal token rates do not mean equal cost per image because consumption varies with model and quality setting - OpenAI image guide. Measure the usage on a few real generations at your chosen quality before promising users a number of images per month.

7. Which OpenAI Model to Spend It On

OpenAI frames its current family in four lines: GPT-6 Astra for "the most demanding reasoning, coding, and professional work," GPT-6.1 Sol for "near-Astra performance for complex work at a lower cost," GPT-6.1 Terra for "visual reasoning, precise computer use, and clear, natural writing," and GPT-6 Luna for "focused, high-volume tasks" - OpenAI. On the Artificial Analysis Intelligence Index as carried in the OpenRouter model feed, Astra scores 56.9, Sol 54.6, Terra 51.3 and Luna 27.9. Astra is OpenAI's highest-scoring model on that index, and Terra, listed on October 26, is its newest general model.

Price per outcome, not price per token

The tempting rule is to use the cheapest model that seems to work. The better rule starts from what you are paying for: a completed task, not a token. A cheaper model that needs three attempts, a longer prompt, or a human to fix its output can cost more per outcome than a stronger model that gets it right once. OpenAI makes this argument for Astra itself, noting that in several evaluations it reached stronger results with substantially fewer output tokens, so its estimated cost per task was lower than earlier models despite higher per-token pricing - OpenAI. That claim is the vendor's, measured on its own tasks, so treat it as a hypothesis to test on yours, not a conclusion.

What follows for a credit-funded product is a simple ladder. Use Luna for anything that is classification, extraction, routing or moderation, where the output is short and the judgment narrow; at a tenth of Terra's price, it turns a $100 grant into hundreds of thousands of calls. Use Terra as the default for user-facing text and anything involving images or screens, which is exactly what OpenAI built it for, at a fifth of Sol's price. Use Sol for complex coding, multi-step tool use and agents that must plan. Reserve Astra for the one hard step in a pipeline where quality is decisive, not for every call. A product that routes this way typically spends most of its tokens on the two cheaper models and most of its quality budget on the two stronger ones. We go deeper on the mechanics in our guide to cutting AI costs with model routing.

The Decisions API: the cheapest judgment on the platform

For one class of work, the most efficient use of the credit is not a chat model at all. The Decisions API evaluates text, images and JSON and returns typed answers (a probability that a condition is true, a choice from a fixed set, or a score against a rubric) about ten times faster than the Responses API, with up to 400 questions per request - OpenAI Decisions guide. It runs only on GPT-6 Luna, and its pricing is unusual: uncached input costs $0.10 per million tokens and output tokens are not charged. For a product that has to decide things constantly (is this ticket urgent, which department owns it, does this photo show damage, is this message spam), that is close to free: a million input tokens of evidence, answered with as many typed judgments as you need, cost a dime.

The design implication is to separate deciding from writing. Let the Decisions API answer the questions that branch your product's logic, and call a writing model only when there is something to write. That split usually cuts both cost and latency, and it makes behavior easier to test, because a typed answer can be checked against labeled examples in a way a paragraph cannot.

Models that are leaving

Part of choosing a model is not choosing one that is about to disappear. On December 11, 2026, OpenAI removes gpt-5, gpt-5-mini, gpt-5-nano, gpt-5-pro, o3 and o3-pro from the API, with GPT-5.6 Sol, Terra and Luna named as replacements; on January 14, 2027, GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini follow, all pointed at gpt-6-luna - OpenAI deprecations. If any code you own still calls those models, the credit is a free way to run the comparison tests a migration needs before the shutdown forces it. Section 13 lists the full calendar.

8. Make the Credit Last: Batch, Flex, Caching and Effort

The same grant can buy twice or ten times as much work depending on four settings, and none of them requires a different model. They are worth setting before the first user arrives, because each is harder to retrofit than to build in.

Batch: half price for work that can wait

The Batch API processes a file of requests asynchronously at a 50% discount, with a separate pool of substantially higher rate limits and completion within 24 hours, often sooner - OpenAI Batch guide. It accepts the Responses, Chat Completions, embeddings, moderation and image generation and editing endpoints. Anything that does not need an answer while a user waits belongs there: nightly enrichment, re-tagging a catalog, summarizing the day's tickets, generating next week's images, running an evaluation set. A batch starts as a JSONL file with one request per line, each with a unique custom_id:

{"custom_id": "item-1", "method": "POST", "url": "/v1/responses", "body": {"model": "gpt-6-luna", "input": "Classify this review as positive, negative or mixed: ...", "reasoning": {"effort": "none"}, "max_output_tokens": 16}}
{"custom_id": "item-2", "method": "POST", "url": "/v1/responses", "body": {"model": "gpt-6-luna", "input": "Classify this review as positive, negative or mixed: ...", "reasoning": {"effort": "none"}, "max_output_tokens": 16}}

Upload the file, then start the batch:

import fs from "fs";
import OpenAI from "openai";

const openai = new OpenAI(); // a project key from the credit-linked organization

const file = await openai.files.create({
  file: fs.createReadStream("reviews.jsonl"),
  purpose: "batch",
});

const batch = await openai.batches.create({
  input_file_id: file.id,
  endpoint: "/v1/responses",
  completion_window: "24h",
});

console.log(batch.id, batch.status);

Each input file may target only one model. Because the credit expires at the end of the cycle, a batch submitted in the last day of a cycle is a reasonable way to spend what is left on work you will use later, such as pre-generating content or labeling data for an evaluation set.

Flex: batch prices without a batch file

Flex processing prices ordinary Responses or Chat Completions requests at batch rates, in exchange for slower responses and occasional unavailability - OpenAI Flex guide. You set service_tier: "flex" on a normal request and raise your client timeout. When Flex lacks capacity it returns a 429 "Resource Unavailable" error and you are not charged for it. Flex is in beta with limited model availability, so check the pricing page for which models support it. It fits background jobs that you would rather not restructure into batch files, such as an agent that works through a queue overnight.

Prompt caching: pay once for the part that repeats

Most products send the same long prefix again and again: the system prompt, tool definitions, a policy document, a product catalog. Prompt caching is on by default for supported models and discounts reused input by up to 95% - OpenAI caching guide. For GPT-5.6 and later, the minimum cacheable prefix is 1,024 tokens; a cache write costs 1.25x the normal input rate for the default 30-minute lifetime or 2.5x for the 12-hour option; and later reads cost 0.1x the input rate on most models and 0.05x on GPT-6.1 Sol and Terra. A write is not an extra fee on top of input: each input token is billed at the uncached, cached or cache-write rate.

The effect compounds with volume. Take a 10,000-token prefix on GPT-6.1 Terra, reused by every request while the cache stays warm. Without caching, every request pays $0.01 for that prefix. With caching, the first request pays $0.0125 to write it and each later one pays $0.0005 to read it. Over 100 requests that is $1.00 against about $0.06; over 500, $5.00 against about $0.26.

The rule that makes caching work is ordering: put everything stable at the start of the prompt and everything that changes (the user's message, today's date, a request ID) at the end, because a cache hit needs an identical prefix. OpenAI suggests the 12-hour lifetime for material reused throughout the day and the 30-minute default for session context that changes more often. Our guide to prompt caching across providers covers the patterns in more depth.

Effort: stop paying for thinking you do not need

Because reasoning tokens bill as output, the reasoning effort setting is a direct cost dial. GPT-6.1 Terra, GPT-6 Luna and GPT-6 Sol support an effort of none, while GPT-6 Astra and GPT-6.1 Sol do not and start at low - OpenAI. For classification, formatting, extraction and short replies, none or low on Terra or Luna removes most of the hidden output. For hard planning steps, a higher effort on a stronger model is often cheaper per outcome than a weaker model retried. GPT-6 also lets you change effort mid-conversation without rewriting the original prefix, which preserves the cache while you spend more thought only on the hard turn. We cover how to tune this in setting the effort dial.

The settings that cost more

Two service tiers spend the credit faster, and both are easy to turn on by accident when copying example code. Fast mode costs 2x standard, and Ultrafast for GPT-6.1 Sol costs $12 per million input and $60 per million output tokens, six times standard - OpenAI pricing. Since October 21, projects can be limited to specific service tiers, and an organization can restrict tiers for every project - OpenAI changelog. For a project that lives on the credit, allowing only standard, flex and batch is a one-time setting that prevents an expensive surprise.

9. Guardrails First: Projects, Keys and Spend Limits

A credit-funded product has an unusual risk profile. The money is free, so the temptation is to skip the controls you would set on a paid account, but the first thing a leaked key or an agent stuck in a loop spends is the grant, and the second thing is whatever comes after it. Setting the guardrails takes ten minutes, and they are the same ones you will need once the product earns money.

One project per product, one identity per workload

Within the linked organization, create a project for each product or environment, so usage, membership and limits are isolated. OpenAI recommends a user-owned project key for your own local development, and a project service account with its own key for a deployed application, scheduled job or CI workflow, so the workload has an identity separate from any individual developer - OpenAI API keys guide. Keys belong on the server: OpenAI says to keep secret keys out of browser code, mobile apps, source control, logs and customer-facing responses, to set expirations that fit your policy, and to rotate by issuing a replacement, switching the workload over and revoking the old key.

A hard ceiling that fails closed

OpenAI gives two spend controls: a spend alert, which only notifies, and a hard spend limit, which makes requests fail with 429 once tracked spend reaches it, at the organization or the project level - OpenAI spend limits. Enforcement is not instantaneous, so recorded spend can slightly exceed the configured amount. For a product living on the grant, a sensible setup is a project hard limit a little under your monthly grant, a spend alert at half of it, and Auto Recharge left off, so the worst case is a paused feature rather than a card charge.

That setup creates failure modes your code must expect. These are the codes OpenAI documents for the situations a credit-funded product will meet:

The last two rows come from OpenAI's rate-limit guide, which adds that a slow_down can occur even within your per-minute limits because it reflects how quickly traffic rose - OpenAI rate limits. The important distinction for your error handling is that the first four are billing states, which retrying will not fix, while the last two are transient. Treat them differently in code: show a friendly "this feature is paused" for the billing states, and retry with backoff for the transient ones. A product that retries a credit_balance_exhausted in a tight loop gains nothing and fills your logs.

Agents need tighter fences

An agent that calls tools, browses or runs code can spend money far faster than a chat feature, because each step re-reads its growing context and can trigger paid tools. Give agent workloads their own project with its own hard limit, cap the number of steps or turns per task in your own code, and log the cost of each run from the usage fields so a runaway pattern is visible the same day. For a checklist of launch-time security beyond spend, see our guide to securing an AI-built app before launch, and for agents that touch real money, our guide to letting an AI agent spend money safely.

10. A Reference Build: Shipping a Product on the Credit

Abstract advice about spending a credit is easy to agree with and hard to act on, so here is one concrete product built to live on a Pro 200 grant. It is an illustration, not a benchmark: the request sizes below are assumptions chosen to show the arithmetic, and a real product should measure its own.

The product

Take a small tool for people who sell second-hand items online. A seller uploads a photo; the product identifies the item, matches it against a catalog of known products, and drafts a listing title and description in the seller's voice. Overnight, it re-checks every active listing against new catalog entries and flags likely mismatches. This is close to the use case OpenAI names for GPT-6.1 Terra, which it suggests for matching product photos to catalog entries and drafting text - OpenAI model page.

The architecture

The design uses three of OpenAI's surfaces, each where it is cheapest:

1. Decisions API on GPT-6 Luna answers the cheap questions first: is this photo usable, which of a fixed set of categories it belongs to, whether it shows visible damage. Output is not charged, and a rejected photo never reaches the more expensive model.
2. Responses API on GPT-6.1 Terra, at low effort, handles the photo-to-listing step, with a long, stable system prompt (style rules, category guidance, examples) placed first so it is cached.
3. Batch API, on GPT-6 Luna or Terra, runs the nightly re-check at half price.

The listing step, as a Next.js route handler (server-side only, using a service-account key from a project in the credit-linked organization):

// app/api/listing/route.ts
import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Stable prefix first, so repeated requests hit the prompt cache.
const STYLE_GUIDE = `You write second-hand marketplace listings.
Rules: plain language, no hype, state condition honestly, ...`;

export async function POST(req: Request) {
  const { imageUrl, sellerNotes } = await req.json();

  try {
    const response = await openai.responses.create({
      model: "gpt-6.1-terra",
      reasoning: { effort: "low" },
      max_output_tokens: 600,
      instructions: STYLE_GUIDE,
      input: [
        {
          role: "user",
          content: [
            { type: "input_text", text: `Seller notes: ${sellerNotes}. Draft a title and description.` },
            { type: "input_image", image_url: imageUrl, detail: "auto" },
          ],
        },
      ],
    });
    return Response.json({ draft: response.output_text, usage: response.usage });
  } catch (err: any) {
    // Billing states are not transient: pause the feature instead of retrying.
    const billing = ["credit_balance_exhausted", "project_spend_limit_exceeded",
                     "organization_spend_limit_exceeded", "organization_usage_limit_exceeded"];
    if (err?.status === 429 && billing.includes(err?.code)) {
      return Response.json({ paused: true }, { status: 503 });
    }
    throw err;
  }
}

The request shape (a user message with an input_text part and an input_image part) follows OpenAI's vision guide - OpenAI. Returning usage to your own logs from day one is what lets you replace the assumptions below with measured numbers.

The arithmetic

Assume, for illustration, that a listing request uses 3,000 input tokens (the cached style guide, the notes and the image) and 400 output tokens at low effort. At Terra's standard rates, before any cache discount, that is $0.003 of input and $0.002 of output, about half a cent per listing. A $200 grant would then cover around 40,000 listings a month, and the cache discount on the repeated style guide lowers the input share further. The Decisions pre-check on Luna costs a fraction of that, and the nightly batch re-check runs at half the standard rate. Even if real image token counts come in at several times the assumption, a product at this scale with a few hundred active sellers stays well inside a Pro 200 grant.

The same arithmetic shows where the grant stops being enough. At 100,000 listings a month the product needs more than a Pro 200 grant can cover on these assumptions, and that is the moment to charge for it. Our guides to pricing an AI product to beat token costs and setting up metered billing pick up from there.

What the grant does not pay for in this build

Everything outside the API stays on your own bill: hosting, the database that stores listings, image storage, a domain, and email. And the code itself is written outside the credit: if you build this with Codex signed in with ChatGPT, that work draws on your plan's usage limits, not the grant. The credit pays for the product's intelligence at runtime, which for many AI products is the largest variable cost, but not the only one.

11. Agents on the Credit, and the Agent Builder Shutdown

Agents are where the credit can do the most and where it disappears fastest, so it is worth separating OpenAI's agent options by who runs what.

The Agents API: OpenAI hosts the agent and its sandbox

The Agents API runs agents on OpenAI's infrastructure, with OpenAI-hosted sandboxes in which the agent can run code and work with files. The credit explicitly covers it, including the hosted sandbox charges - OpenAI API docs. Model usage is billed separately at the chosen model's API rates and the sandboxes use standard container rates, which start at $0.03 per 20-minute session for a 1 GB container - OpenAI hosted environments. The API has moved quickly this autumn: sandbox compute has been billed only during active turns since October 9, hosted sandboxes gained the Artifact SDK and skills for spreadsheets, presentations and Word documents on October 16, and eligible projects could turn on automatic review of agent actions from October 30 - OpenAI changelog. It is still a beta API, accessed through the SDK's beta namespace, which is the main reason it scores lower on production fit in the table at the top.

The Agents SDK: you host the loop

The Agents SDK is the code-first alternative: the agent loop runs in your own application and calls models through the API, so the model usage it generates is ordinary API usage, paid by the credit like any other request made with a key from the linked organization. You trade OpenAI's hosted sandbox for control over where the agent runs, what it can touch and how long it may work, which is often the right trade for a product that must keep customer data in its own infrastructure.

Agent Builder shuts down on November 30

OpenAI's visual workflow tool is leaving. OpenAI notified developers on June 3 that Agent Builder is deprecated and scheduled to shut down on November 30, 2026, while ChatKit remains available - OpenAI deprecations. The migration path is to export each workflow as Agents SDK code, then either run that code in your own application or recreate the workflow as a ChatGPT Workspace Agent. The export does not convert your workflow graph, and OpenAI warns it does not guarantee that every behavior transfers unchanged - OpenAI migration guide. The export lives in Agent Builder's Code dialog:

As the dialog shows, you choose Agents SDK, pick TypeScript or Python, and copy the complete export. Two other platform products end the same day: the v1/prompts API and reusable prompt objects, and the Evals dashboard and API, which became read-only on October 31 - OpenAI. If you have workflows in any of the three, the credit is a practical way to pay for re-running them on the new path and comparing results before the cutoff.

Keeping agent spend predictable

The cost of an agent is driven by how many turns it takes and how much context each turn re-reads, not by the price of a single call. Three habits keep that bounded on a fixed grant. Keep the stable parts of an agent's instructions and tool definitions at the front so turns hit the prompt cache. Use a cheap model for the steps that only route or check, and the stronger model only for the steps that plan. And end every run with a hard cap in your own code, on turns and on cost, so a task that cannot finish fails cheaply instead of spending the month's grant in an afternoon. For running several agents at once, our playbook for orchestrating parallel agents goes further.

12. Pro, Business, Claude or Google: Which Credit Is Worth Most

The three labs' subscriber credits look alike at a glance and differ in the details that decide their value. The table compares them as their own documentation describes them on November 6, 2026.

The OpenAI column comes from OpenAI's guide, the Anthropic column from Anthropic's help center - Claude Help Center, and the Google column from Google's January announcement - Google.

Reading the comparison

The biggest single grant is OpenAI's: Pro 500 is the only plan that hands one person $500 a month. Anthropic's team structure is the same as OpenAI's Business pooling to the dollar, down to the $20 and $100 seat amounts and the $500 cap, which suggests one lab set the template and the other matched it. Google's offer is smaller and differently shaped, a cloud credit that also pays for deployment (Cloud Run), which makes it useful for hosting, not only inference.

The structural difference worth noticing is the annual upfront grant. A Business workspace billed annually receives up to $6,000 at once, expiring at the end of the year. That gives a team freedom to spend heavily during a launch month and lightly afterward, but it also concentrates the expiry risk: an unspent annual grant is lost all at once. Anthropic's annual plans receive credits monthly, which smooths the spending and spreads the loss.

Which one should a builder hold

The honest answer is that each credit is worth exactly what you would spend on that lab's models. A credit for a platform you will not build on is worth nothing, however large. So the question is which models your product should run on, and only then which subscription carries the matching credit. For a product that routes between labs, which is increasingly common, holding two subscriptions means two separate grants, each spendable only on its own platform. If you already pay for both ChatGPT Pro and Claude Max for daily work, claim both credits and route each model's traffic to its own funded organization. Our comparison of Claude Sonnet 5.5 and GPT-6.1 Sol and our guide to claiming the Claude Max credit cover the Anthropic side in the same depth as this guide.

13. When the Credit Runs Out: Failure Modes and Deadlines

The ways this benefit goes wrong are few, predictable and mostly cheap to prevent. They fall into three groups: the money runs out, the link breaks, and the models change underneath you.

The money runs out

The commonest failure is the simplest: a product that worked all month stops on the day the grant is spent, with a 429 and credit_balance_exhausted. Decide in advance which behavior you want. A side project can pause gracefully until the next grant; a product with paying users needs a small purchased buffer, a spend alert well before the grant runs out, and a hard limit above it so a bug cannot drain the buffer too. The opposite failure is just as real and invisible: breakage, the grant that expires unused because nothing was built to spend it. The credit does not roll over, so a month without a project is a month's grant gone.

The link breaks

The link between subscription and organization can lapse in ways that are easy to miss. A downgrade to Plus, Go or Free removes it at the end of the cycle, a move from Business to Enterprise removes it, and a move from Pro to Business ends the Pro link and requires a new claim after seven days on Business - OpenAI. Renewals can also lag: subscribers on OpenAI's forum have reported a renewal grant appearing only days after the subscription renewed, and mobile-billed subscribers have reported claims that never appear. If your product depends on the grant arriving on a given day, keep a few days of purchased buffer for the start of each cycle.

OpenAI also frames the benefit as conditional. Credits arrive at renewal "while these benefits are available," which is a reminder that a promotional benefit can change. Build the product so that its economics survive without the grant, and treat the grant as a subsidy, not a foundation.

The models change underneath you

The weeks after this launch are crowded with shutdowns across all three labs, and a product built on the credit should not be built on a model that is about to vanish. The calendar, from each vendor's own deprecation page:

The OpenAI rows come from OpenAI's deprecations page - OpenAI. The Anthropic row comes from Anthropic's model deprecations page - Anthropic. The Google rows come from the Gemini API's deprecations page - Google AI for Developers.

The Google entry deserves a second look because it fails silently. From December 1, requests to gemini-2.5-pro will automatically route to gemini-3.8-flash, and requests to gemini-2.5-flash to gemini-3.5-flash-lite: nothing errors, the model behind your calls simply changes. OpenAI offers a programmatic check for its own side: the list models endpoint returns an optional shutdown_date on each model, so a scheduled test in your own code can flag a model with a date before it stops answering. The credit is a free way to run those comparisons, so spend part of a cycle on them now rather than learning about a shutdown from your users.

14. Routes From Idea to Live Product, and Where the Credit Fits

The credit pays for one layer of a product: the intelligence it uses at runtime. Getting from an idea to a live product also takes writing the code, hosting it, and running everything around it, and each route through those steps uses the credit differently.

Writing the code is a different budget

For most Pro subscribers the code will be written with Codex signed in with ChatGPT, which draws on the plan's included usage, doubled for all Pro tiers and Business Premium on October 29. That is the right place to write code, because plan usage is flat and the credit is not spent. The credit takes over the moment the product itself starts calling models. Keeping that split clear avoids the most common mistake with this benefit: switching Codex to an API key in the hope of paying with the grant, which the benefit does not support.

The routes, and how each one uses the credit

Building it yourself with Codex or another coding agent, and hosting on a platform you choose, gives full control and uses the credit most directly: your server holds a key from the linked organization and every model call your product makes draws on the grant. The cost is that you own hosting, the database, payments, email and security yourself. Our guide to where to deploy your app compares the hosting options.

OpenAI's own surfaces are moving in the same direction. Sites is included with eligible ChatGPT plans during its public beta - OpenAI Codex pricing, and OpenAI's credit guide points subscribers to the OpenAI Developers plugin in ChatGPT, which can create API keys and build alongside ChatGPT Sites. That is the shortest path from the claim to something running, though what Sites is actually built for matters; our founder's guide to OpenAI Sites looks at where it fits and where it does not.

AI app builders turn a description into a running product and handle hosting for you. Where a builder bundles the AI into its own pricing, the credit does not help; it helps only where the builder lets the product you build call OpenAI with your own key. Founden is one option of this kind for autonomous software: its desktop app drives Claude Code or Codex on the AI plan you already pay for (choosing between them is a paid-plan feature), and a company's own AI key, such as one from the organization your credit is linked to, is the one its product uses in production. Our ranking of the top AI app builders compares the field on equal terms.

Letting users pay is the route that removes the ceiling altogether. With Sign in with ChatGPT, a product can run requests on each user's own ChatGPT plan, so runtime cost scales with users who already pay OpenAI. The credit then funds the build and your own testing, and the users fund the runtime.

Where the credit fits on each route

Across all four routes, the credit plays the same role: it is the cheapest possible source of runtime AI for the first months of a product, before it has revenue to pay for its own. The route decides how much of the rest of the cost you carry yourself. A builder who hosts their own product pays for hosting and owns the most; a builder on a managed platform pays the platform and owns less of the infrastructure; a product that lets users pay shifts runtime cost off its own books. None of them changes the basic arithmetic of the grant: it is worth what your product spends on OpenAI's models in a month, up to the grant amount.

15. A Decision Framework

Everything above reduces to a handful of decisions, and most people will only need two or three of them.

If you already pay for Pro or Business

Claim the credit now, even with no project planned: the claim costs nothing, the first grant is prorated from the day you claim, and every cycle you wait is a grant you cannot recover. Link it to an organization you use only for experiments, unless you deliberately want it to subsidize existing traffic. Check the organization's approved usage limit before relying on a grant above $100. Then put the first grant to work on something small and real: a feature for a product you already have, a migration test for a model on the shutdown list, a batch job that labels data you will use anyway.

If you are deciding whether to upgrade for the credit

The arithmetic is direct. Pro 100 costs $100 and returns $100 of API credit, so if you would spend at least $100 a month on OpenAI's API anyway, the Pro plan's apps and Codex usage are effectively free, as long as you actually spend the grant each month. The same holds at $200 and $500. If you would not spend that much on the API, the upgrade has to be justified by Pro's own features, and the credit is a bonus whose value depends on building something. For a Plus subscriber who builds occasionally, the case for upgrading on the credit alone is weak; for one who already pays for the API each month, it can be strong.

If you run a team

Business pooling rewards Premium seats: five Premium seats or 25 Standard seats reach the $500 cap, and seats beyond the cap add nothing to the credit. Annual billing turns the monthly allowance into a single grant of up to $6,000, which suits a team that builds in bursts and punishes one that forgets to spend it. Make sure the workspace owner also owns the receiving API organization under the same email, and decide who in the team may create keys in it.

Before the first key goes into production

1. Create a project for the product inside the linked organization.
2. Issue a service-account key for the deployed app; keep it on the server.
3. Set a project hard spend limit just under the grant and a spend alert at half.
4. Restrict the project's service tiers to standard, flex and batch.
5. Handle the four billing 429s as "paused," and retry only the transient errors.
6. Put stable prompt content first so it caches, and set reasoning effort per call.
7. Move anything that can wait into the Batch API.
8. Log usage per request and compare it with the grant weekly.

The benefit is a genuine change in what it costs to start an AI product: for anyone already paying for Pro, the first months of runtime AI can now cost nothing. What it does not change is the work of building something people want and the discipline of running it within a budget. The grant rewards the second as much as the first.

This guide reflects OpenAI's ChatGPT API credits benefit and API pricing as documented on November 6, 2026. OpenAI describes the benefit as available "while these benefits are available," and prices, models and limits change often, so check the linked documentation before you rely on a specific figure.

What this article rests on

Every model figure linked above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.

• GPT-6.1 Terra (OpenAI): $1 in and $5 out per million tokens, cached input $0.05, a 1.05M token window, listed 26 October 2026.
• GPT-6 Astra (OpenAI): $10 in and $50 out per million tokens, cached input $1, a 1.05M token window, listed 4 September 2026.
• GPT-6.1 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 29 September 2026.
• GPT-6 Luna (OpenAI): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1.05M token window, listed 22 September 2026.

In this topic: AI costs

• AI Receptionist Cost per Call: Build vs Buy (2026)
• Claude Max API Credits: Claim Them, Ship an App (2026)
• Sign in with ChatGPT API: Users Pay Your AI Bill (2026)
• Cut AI Costs With Prompt Caching (2026)
• GPT-6 Astra Pricing: What Your App Really Pays 2026
• Set Up Metered Billing for Your AI Product 2026
• Price Your AI Product to Beat Token Costs 2026
• Set the Effort Dial to Cut AI Costs (2026)

What does AI cost to run, and how do you cut it? Every guide on it

Data behind this topic: AI model prices, context windows and release dates.