ChatGPT Pro API Credits: How to Claim and Use Your $100 Monthly Grant

ChatGPT Pro 100 includes $100 in API credits for a full monthly cycle. See how to claim them, why your first grant may be smaller, and what a WordPress drafting request could cost.

ChatGPT Pro 100 offers $100 in API credits per full monthly cycle, illustrated by a glowing cyan code symbol.

ChatGPT Pro 100 includes $100 in OpenAI API credits for a full monthly billing cycle. To claim them, link your subscription to an API organization you own. Once the grant appears there, you can use it for eligible work such as generating text, creating images, or testing an app that sends drafts to WordPress. Your first grant can be smaller if you activate the benefit partway through your billing cycle.

Which ChatGPT plans include OpenAI API credits?

The amounts below are in US dollars and show what each plan contributes for a full monthly billing period. Business seat contributions go into a shared workspace grant.

ChatGPT plan Eligible for this benefit? API credits for a full monthly cycle
Go No $0
Plus No $0
Pro 100 Yes $100
Pro 200 Yes $200
Pro 500 Yes $500
Business Standard Yes, per paid seat $20 per seat
Business Premium Yes, per paid seat $100 per seat

Monthly Business billing. The combined Standard and Premium contributions are capped at $500 per workspace per monthly billing cycle. For example, 12 Standard seats and 3 Premium seats contribute $240 and $300, respectively. The cap brings the $540 total down to $500.

Annual Business billing. If the workspace pays for the year upfront, OpenAI issues the full-year grant at once, capped at $6,000 per workspace per annual cycle. A first claim partway through that cycle is prorated for the remaining paid term. The grant expires at the end of the annual cycle.

How to claim your API credits and check the balance

Your eligible paid subscription must have been active for at least seven days. Use the same email address in ChatGPT and on the OpenAI API Platform. You must own the Pro subscription or Business workspace and be an owner of the receiving API organization, with permission to manage its billing. On Business, an admin role alone is insufficient. Trials and complimentary subscriptions are ineligible. Availability can also depend on your country and whether the offer has reached your account.

  1. In ChatGPT, open Settings → Billing for Pro. For Business, open the workspace’s billing settings in ChatGPT or the Admin Console.
  2. Find the API credits benefit and start the claim.
  3. Select the API organization that will run your workloads. If you are new to the platform, you can select your Personal API Organization. Each subscription or Business workspace links to one API organization, and each API organization can have one active link for this benefit.
  4. Review the organization and the amount of the first grant, then confirm.
  5. On the API Platform, switch to the linked organization and open its Credit grants page to see the grant, available balance, and expiration date.

You can also start the claim from Billing in the API Platform. An active promotional grant can fund eligible API requests without an API payment method.

Why might your first Pro 100 grant be $35?

Suppose you claim the benefit when about 35% of your current Pro 100 billing cycle remains. Applying that fraction to the $100 full-cycle allowance gives an illustrative first grant of $35. The amount shown in the claim flow reflects the time remaining in your actual cycle.

At your next subscription renewal, OpenAI automatically issues the $100 full-cycle grant if your subscription remains eligible and the benefit is still available. You claim once, and each monthly grant expires at the end of its own billing cycle. Any unused portion of the $35 expires at renewal.

Do projects share the same credit balance?

Yes. Eligible calls from projects in the linked API organization draw down its shared balance. For example, a WordPress drafting project and an image generation project can both use the same grant through their own project API keys. If your key belongs to another API organization, its requests use that organization’s billing. Business teammates still need access to the relevant API organization and projects.

OpenAI spends promotional API credits first. When those run out, what happens depends on the organization’s remaining balance.

Balance after promotional credits are exhausted What happens to eligible API calls
Purchased API credits remain Requests continue and draw on the purchased balance.
No credits remain Requests fail with HTTP 429 and the error code credit_balance_exhausted.

You can resume after adding purchased credits or when your next eligible grant arrives. A positive balance still leaves model access and API rate limits in effect.

What can you build with these credits?

Consider a PHP script that turns editorial notes into a WordPress draft. The script first sends the notes to the OpenAI Responses API using a project key from the linked organization. It then sends the generated text to WordPress with status set to draft, so an editor can review it before publication. In this workflow, the OpenAI grant funds the eligible model request. WordPress authenticates its own request with an Application Password over HTTPS.

The example uses PHP 8 or later with cURL. Set OPENAI_API_KEY, WP_BASE_URL (the site’s HTTPS URL), WP_USER, and WP_APP_PASSWORD in your environment. The WordPress user needs permission to create posts. Save the script as draft.php and run php draft.php notes.txt with a local text file containing your notes.

<?php

function requiredEnv(string $name): string
{
    $value = getenv($name);
    if ($value === false || $value === '') {
        throw new RuntimeException("Missing environment variable: $name");
    }

    return $value;
}

function postJson(string $url, string $authorization, array $payload): array
{
    $request = curl_init($url);
    curl_setopt_array($request, [
        CURLOPT_POST => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 10,
        CURLOPT_TIMEOUT => 120,
        CURLOPT_HTTPHEADER => [
            "Authorization: $authorization",
            'Content-Type: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    ]);

    $body = curl_exec($request);
    if ($body === false) {
        throw new RuntimeException(curl_error($request));
    }

    $status = curl_getinfo($request, CURLINFO_RESPONSE_CODE);
    if ($status < 200 || $status >= 300) {
        throw new RuntimeException("Request failed with HTTP $status.");
    }

    return json_decode($body, true, 512, JSON_THROW_ON_ERROR);
}

$notes = file_get_contents($argv[1] ?? 'notes.txt');
if ($notes === false || trim($notes) === '') {
    throw new RuntimeException('Provide a non-empty editorial notes file.');
}

$site = rtrim(requiredEnv('WP_BASE_URL'), '/');
if (!str_starts_with($site, 'https://')) {
    throw new RuntimeException('WP_BASE_URL must use HTTPS.');
}
$wpCredentials = requiredEnv('WP_USER') . ':' . requiredEnv('WP_APP_PASSWORD');

$response = postJson(
    'https://api.openai.com/v1/responses',
    'Bearer ' . requiredEnv('OPENAI_API_KEY'),
    [
        'model' => 'gpt-6.1-sol',
        'instructions' => 'Draft a short blog post body in plain text using only the supplied notes.',
        'input' => $notes,
    ]
);

if (($response['status'] ?? null) !== 'completed') {
    throw new RuntimeException('The model response did not complete.');
}

$textParts = [];
foreach ($response['output'] ?? [] as $item) {
    foreach ($item['content'] ?? [] as $part) {
        if ($part['type'] === 'output_text') {
            $textParts[] = $part['text'];
        }
    }
}

$draft = trim(implode("\n", $textParts));
if ($draft === '') {
    throw new RuntimeException('The model returned no draft text.');
}

$escapedDraft = htmlspecialchars($draft, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
$post = postJson(
    $site . '/wp-json/wp/v2/posts',
    'Basic ' . base64_encode($wpCredentials),
    [
        'title' => 'Editorial draft',
        'content' => '<p>' . nl2br($escapedDraft) . '</p>',
        'status' => 'draft',
    ]
);

if (($post['status'] ?? null) !== 'draft' || !isset($post['id'])) {
    throw new RuntimeException('WordPress did not confirm draft creation.');
}

echo "WordPress draft ID: {$post['id']}\n";

For a workflow where an AI assistant calls WordPress operations directly, see DemystIA’s guide to the WordPress MCP Adapter and site permissions.

How much would one draft-generation call cost?

At OpenAI’s Standard rates on November 17, 2026, gpt-6.1-sol costs $2 per million uncached input tokens and $10 per million output tokens. Assume one request with 5,000 uncached input tokens, 2,000 total billable output tokens including any reasoning tokens, and no tool or other surcharges.

Component Calculation Estimated cost
Input 5,000 ÷ 1,000,000 × $2 $0.010
Output 2,000 ÷ 1,000,000 × $10 $0.020
Total $0.030

That is an estimate of three cents per OpenAI call under those assumptions. Use the usage object returned by the API to check the actual token counts for your requests. The cost can change with the model, token counts, caching, or any tools the workflow uses.

Do ChatGPT Pro API credits cover Codex?

Codex authenticated with an API key is excluded from this grant. When you sign in to Codex with ChatGPT, usage follows the Codex allowance of your ChatGPT subscription.

Eligible usage billed to the linked API organization can draw from the grant. That includes text generation and image understanding through the Responses API, and image generation or editing through the Images API. Your PHP script can use the Responses API for a text or code-generation task under this benefit.

For more on the amounts included in ChatGPT and how paid usage credits can extend signed-in features, see DemystIA’s guide to ChatGPT usage limits and credits.

Sources