OpenAI Error: insufficient_quota — Quota Exhausted

import openai

try:
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello"}],
    )
except openai.RateLimitError as e:
    # e.status_code == 429
    # e.code == 'insufficient_quota'
    # e.type == 'insufficient_quota'
    # e.message includes 'You exceeded your current quota, please check your plan and billing details.'
    if e.code == 'insufficient_quota':
        alert_billing_team()
        raise  # don't retry

insufficient_quota is OpenAI’s billing-out signal dressed up as HTTP 429. Unlike rate_limit_exceeded (which means “slow down”), insufficient_quota means “you’ve run out of money, retrying won’t help, fix billing.” The two errors share a status code but require completely different handling — and conflating them is one of the most common bugs in production OpenAI integrations.

The fix is rarely in code. It’s in your billing setup: a card on file, auto-recharge enabled, soft/hard limits set high enough for production, and an alerting system that pages you when balance drops. Get those right and you’ll never see insufficient_quota outside a deliberate spend cap. Get them wrong and you’ll have a silent outage every time the prepaid balance ticks to zero.

Why this happens

• Free trial credit exhausted or expired. New OpenAI accounts get a small amount of free credit ($5 historically, less now) that expires after 3 months. Once spent or expired, every request fails `insufficient_quota` until you add a payment method. The dashboard shows the remaining trial balance under Billing → Overview.
• Monthly hard usage limit reached. Even on paid plans, OpenAI enforces a soft and hard usage cap per month (set in Billing → Limits). Hitting the hard limit blocks all further requests until the next billing cycle or you raise the cap. The default for new paid orgs is often $120/mo — easy to hit on production traffic.
• Payment method failed and credit isn't auto-topping up. OpenAI's auto-recharge depends on a working card. If a charge fails (expired card, decline), auto-recharge stops and your balance drops to zero. The org continues running until the credit hits zero, then every call fails `insufficient_quota` until you fix billing.
• Org never added a payment method. Some teams sign up, get the API key working with trial credit, then forget to add a card. Once trial credit runs out, the API stops cold. Common with side projects that ramp up unexpectedly when they get attention.
• Project-level spend cap reached (Projects feature). If your org uses Projects, each project can have its own monthly spend cap. Hitting a project cap returns `insufficient_quota` even though the org has plenty of headroom. Look at Settings → Projects → [your project] → Limits.

How to fix it

Fixes are ordered by likelihood. Start with the first one that matches your context.

import openai
from openai import RateLimitError

def safe_call(messages, model="gpt-4o"):
    try:
        return openai.chat.completions.create(model=model, messages=messages)
    except RateLimitError as e:
        if e.code == 'insufficient_quota':
            # Page billing — do not retry
            notify_pagerduty('OpenAI quota exhausted', severity='critical')
            raise QuotaExhaustedError() from e
        # Real rate-limit — retry with backoff handled elsewhere
        raise

# OpenAI doesn't yet expose balance via API.
# Workaround: track your spend client-side from response.usage and alert.
from collections import defaultdict
spend_today = defaultdict(float)

PRICE = {"gpt-4o": (2.50/1e6, 10.00/1e6)}  # input, output per token

def track(response, model):
    in_p, out_p = PRICE[model]
    cost = response.usage.prompt_tokens * in_p + response.usage.completion_tokens * out_p
    spend_today[model] += cost
    if sum(spend_today.values()) > DAILY_BUDGET:
        alert("Daily OpenAI budget exceeded")

Detection and monitoring in production

Tag `insufficient_quota` errors distinctly from `rate_limit_exceeded` in your monitoring. The former should fire a critical alert (production is down), the latter is informational. A single `insufficient_quota` error means every subsequent call will also fail — don't dedupe to a single alert per hour, page immediately. Track daily token spend client-side from `response.usage` since OpenAI doesn't expose live balance via API.

Read more: /guide/handling-rate-limits/