ChatGPT Pro and Business now include up to $500 a month in OpenAI API credits. Choose the receiving organization before you claim

Since 28 October, a paid ChatGPT Pro or Business subscription comes with monthly credits for the OpenAI API: $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. Nothing is applied until you link the subscription to an API organization, and according to OpenAI's guide to the benefit, unused credits expire at the end of the billing cycle and do not roll over.

That billing cycle is your ChatGPT subscription's, so the deadline each month is your renewal date, not the first of the month. The first grant is prorated for whatever is left of the current cycle, which means a Pro $200 subscriber who renews on the 10th and claims on the 2nd gets roughly a week's worth.

Claiming takes a few minutes in ChatGPT under Settings → Billing (Pro), in the workspace billing settings or Admin Console (Business), or from the Billing page on the API Platform. One step deserves more care than the rest: picking the API organization that receives the credits. The guide's only route for changing it afterwards is to contact support.

Four conditions that block the claim

• The subscription is paid, active and at least seven days old. Free trials and complimentary subscriptions do not qualify. ChatGPT Enterprise is not eligible at all.
• You own both sides. You must own the ChatGPT subscription or Business workspace, and be an owner of the API organization that receives the credits. Being a member of the organization is not enough.
• The email addresses match. The guide requires "the same email address for your ChatGPT account and the API account used to link the organization." If your ChatGPT login is a personal address and your API account was created under a work address, the claim will not find a match. The fix is to claim into an organization you own under the ChatGPT address.
• On Business, the pool stops at $500. That is 25 paid Standard seats or 5 Premium seats. A workspace with 60 Standard seats gets the same $500 as one with 25. Workspaces that pay annually receive the whole year, up to $6,000, in one grant that expires at the end of the annual cycle.

The organization decides what the credits do

Every project API key in the linked organization draws on the grant, and keys from any other organization draw nothing. Two setups make sense, and they solve different problems.

	Link the organization you already pay for	Link a separate organization with no payment method
Effect	Your existing traffic spends the grant first ("Your organization uses free API credits before purchased API credits"), so the invoice drops by up to the grant with no code change	A sandbox funded only by the grant
When the grant is used up	Usage continues on your purchased credits	Requests fail with HTTP 429 and credit_balance_exhausted, and nothing is charged
Usage tier	Unchanged	Depends on credit purchases (next section)
Pick it when	The organization already spends at least the grant each month	You want agents, experiments or a scheduled job that cannot cost more than the grant

If you already spend $200 a month on the API, linking a Pro $200 plan to that organization is the straightforward saving: the same traffic, a smaller invoice.

The separate organization suits work you would not leave running on a card. An agent stuck in a loop there ends with a 429, not an invoice. Two things remove that ceiling: Auto Recharge, which the guide recommends turning on "to continue building without errors and interruptions", and purchased credits sitting in the organization, which are spent once the grant is gone. On a sandbox organization, leave Auto Recharge off and keep any purchased balance small.

Check the tier of a new organization

OpenAI's rate limit guide says an organization's usage tier "upgrades automatically as its total credit purchases reach each threshold": Build at $5 of purchases, Launch at $100, Grow at $500. An organization with no purchases is on the Free tier, whose monthly usage limit is $100, and the rate limit tables on the model pages for GPT-6 Astra, GPT-6.1 Sol and GPT-6 Luna list only Build, Launch and Grow. Neither guide says whether a granted credit counts toward a tier.

So if you link a Pro $200 or $500 plan to a new organization, open Settings → Organization → Limits right after the claim and read three things: the tier, the monthly usage limit, and whether the models you plan to call show a rate limit. If the page says Free, one $5 credit purchase moves the organization to Build, with a $500 monthly usage limit. Your ceiling becomes the grant plus $5 while Auto Recharge stays off. If you skip this and the organization stays capped at $100, the error you hit is organization_usage_limit_exceeded, not credit_balance_exhausted, and the rest of the grant expires unused.

Find out which organization a key belongs to

If you have API keys scattered across scripts and are not sure which organization each one bills, a Responses API call returns the organization in an openai-organization response header. The models list endpoint does not return that header, so use a minimal request to the cheapest model:

curl -s -D - -o /dev/null https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "content-type: application/json" \
  -d '{"model": "gpt-6-luna", "input": "ok", "max_output_tokens": 16}' \
  | grep -i '^openai-organization'

The header appears even when the request is refused for lack of credits, so this also works on an organization that has run dry.

What the grant does not pay for

The guide lists the Responses, Agents (including OpenAI-hosted sandbox charges), Decisions, GPT-Live and Realtime, and Images APIs, plus built-in tools such as web search, file search and Code Interpreter. Two exclusions matter if you build with Codex:

• Codex through an API key is not covered. If you run codex exec in CI with an API key, do not budget that spend against the grant.
• The credits do not raise your ChatGPT or signed-in Codex usage limits. They are a separate pool for code you write against the API, not extra headroom in the apps.

What a nightly job costs, by model

The model you call decides how long a grant lasts. Take a nightly job that reads 300 support tickets of about 2,000 tokens each and writes a 300-token summary for each one: 600,000 input tokens and 90,000 output tokens a night. At the standard prices on OpenAI's model pages:

Model	Input / output per 1M tokens	Per night	Per 30 nights
GPT-6 Luna	$0.10 / $0.50	$0.105	$3.15
GPT-6.1 Sol	$2 / $10	$2.10	$63
GPT-6 Astra	$10 / $50	$10.50	$315

On Luna, a Pro $100 grant covers that job about 30 times over. On Astra, the same job overruns a Pro $200 grant before the month ends. Before you spend the grant on the flagship, run your task on the cheapest model and check whether its output passes.

When the grant runs out, the SDKs retry anyway

On a sandbox organization, the end of the grant arrives as an error, and the default client settings treat that error as something to retry. We sent requests on 2 November from an organization with no credits left. The response was HTTP 429 with "type": "insufficient_quota" and "code": "credit_balance_exhausted", and it carried neither a Retry-After nor an x-should-retry header. Both official SDKs retry a 429 unless that header says not to, so the Python library (3.42.1) and the Node library (7.47.0) each sent three requests before raising RateLimitError. In Python that took between three and six seconds per call. A batch loop that catches the error, logs it and moves on to the next item spends those seconds again on every remaining item, and an application-level retry wrapper on top multiplies the request count.

Turn the SDK retries off and keep one retry policy that reads error.code:

import random
import time

import openai
from openai import OpenAI

STOP_CODES = {
    "credit_balance_exhausted",
    "organization_spend_limit_exceeded",
    "project_spend_limit_exceeded",
    "organization_usage_limit_exceeded",
}

client = OpenAI(max_retries=0)  # one retry policy, in one place

def create(**kwargs):
    for attempt in range(6):
        try:
            return client.responses.create(**kwargs)
        except openai.RateLimitError as e:
            if e.code in STOP_CODES:
                raise  # out of credit or over a limit: waiting will not fix it
            retry_after = e.response.headers.get("retry-after")
            delay = float(retry_after) if retry_after else min(60, 2 ** attempt) + random.random()
            time.sleep(delay)
    raise RuntimeError("still rate limited after 6 attempts")

Against the real API, this raised after a single request. Against a local test server answering with a rate-limit 429 and Retry-After: 1, it waited and tried six times before giving up, which is the behaviour you want for a rate limit. In Node, the same switch is new OpenAI({ maxRetries: 0 }), and the code is on err.code. Why error.type alone cannot tell these cases apart, and the matching stop codes on other vendors, are in our post on spending limits that only send an email.

If your plan changes

• Upgrading Pro within a cycle can add prorated credits for the rest of that cycle. Grants never exceed $500 per cycle.
• Cancelling stops new grants but does not revoke credits already issued; they stay usable until they expire.
• Downgrading to Plus, Go or Free removes the organization link at the end of the billing cycle.
• Moving from Pro to Business ends the Pro link. A workspace owner can link again once the Business subscription has been active for seven days.
• Moving from Business to Enterprise removes the link at the end of the cycle, and Enterprise cannot claim it again.

Once linked, the grant arrives with each renewal without another claim. The recurring task is checking the Usage dashboard a few days before your ChatGPT renewal date, while there is still time to point a job at what is left.