Do LLM API credits expire? The short answer is that it depends on the provider and whether you’re holding a promotional grant, a prepaid credit wallet, or running on standard metered billing. This analysis breaks down the actual policies across the major inference platforms so you can architect cost controls without nasty surprises at month’s end.
The two settlement models
Most teams conflate “credits” with “balance.” They are different accounting primitives.
Promotional or trial credits
These are subsidies. A provider gives you $5–$300 to kick the tires. The grant is a liability on their books, so they cap its life. OpenAI’s legacy free trial gave $18 that expired in three months. Vertex AI’s $300 free trial expires in 90 days. The intent is to force evaluation, not to fund production.
Prepaid credit wallets
You deposit cash, get a credit balance, draw down per request. This is common among aggregators and some GPU clouds. Expiration here is a policy choice, not a technical necessity. Together AI and OpenRouter both sell such wallets; neither expires them. Some regional resellers do expire after 12 months to force re-engagement.
Pure metered billing
No wallet. You send requests, provider meters tokens, invoices monthly or charges card per threshold. OpenAI’s paid tier, Anthropic’s API, and Azure OpenAI work this way. The question “do LLM API credits expire” is irrelevant because there is no credit to expire.
Provider-by-provider breakdown
OpenAI
Paid API usage is pay-as-you-go against a payment method. There is no prepaid credit that expires. However, if you created an account during the free-credit era, those credits had a hard 3-month expiry. Today, new accounts get a small amount of free tier usage with the same expiry. Engineering implication: never architect a production path that depends on free grants.
# OpenAI has no credits endpoint; track spend via usage export
import csv, datetime
with open("openai-usage.csv") as f:
rows = list(csv.DictReader(f))
# sum line_item_amount columns; no expiry field existsAnthropic
Claude API is metered per token. Promotional console credits (e.g., $5 for new signups) expire after a fixed window, typically 3 months. Production traffic bills to your card. If you’re building a long-lived agent, assume metered and ignore credit expiry.
Google Vertex AI
Vertex gives $300 free trial credits that expire 90 days after account creation. Once converted to a paid project, you are on metered billing with contractual terms. If you pin to Vertex for a specific model (e.g., Gemini), set a budget alert—not because credits expire, but because per-token costs can spike.
Azure OpenAI
Enterprise agreements may include committed-use discounts, but the base API is metered. The Azure free account gives $200 credit expiring in 30 days. For production, you sign a contract; expiration is not a factor.
Together AI
Together sells prepaid credits through its dashboard. According to their documentation, credits do not expire. You can query the balance programmatically:
import requests
r = requests.get("https://api.together.xyz/v1/credits",
headers={"Authorization": f"Bearer {TOGETHER_KEY}"})
print(r.json())
# {'creditBalance': 24.10, 'totalCredits': 100.0, 'usedCredits': 75.9}This is a clean model for teams that want predictable prepaid spend without watching a clock.
Replicate
Replicate bills per second of GPU time. No credit wallet; you add a card and pay. Expiration does not apply.
OpenRouter and gateways
OpenRouter uses a non-expiring credit wallet. An OpenRouter-class gateway like n4n.ai instead exposes an OpenAI-compatible endpoint across 240+ models with per-token usage metering and automatic fallback when a provider is degraded. It bills against a payment method rather than selling expiring credit packs, so the query “do LLM API credits expire” is moot at that layer. The gateway forwards provider cache-control hints and honors routing directives, but does not introduce its own credit expiry.
How to check your exposure programmatically
If you operate across multiple providers, centralize balance checks. For providers with a credits API, poll on a schedule. For metered-only providers, pull usage exports.
def aggregate_exposure():
exposure = {}
# Together: non-expiring
t = requests.get("https://api.together.xyz/v1/credits",
headers={"Authorization": f"Bearer {TOGETHER_KEY}"}).json()
exposure["together"] = t["creditBalance"] # no expiry
# OpenRouter: non-expiring
o = requests.get("https://openrouter.ai/api/v1/credits",
headers={"Authorization": f"Bearer {OR_KEY}"}).json()
exposure["openrouter"] = o["data"]["total_credits"] - o["data"]["total_usage"]
# Vertex: parse billing export for remaining promo
# ...
return exposureStore the results with timestamps. If any balance has an expires_at field, alert 7 days prior.
Tradeoffs for engineering teams
Capacity planning with expiring credits
Expiring grants push you to front-load experiments. That’s fine for prototypes but dangerous for steady-state. A common failure: a team builds a nightly batch job to “use up” credits before expiry, wasting compute and masking true unit economics.
Avoiding waste on non-expiring wallets
Non-expiring prepaid looks safe, but it’s a sunk cost that biases you toward a single vendor. If you deposit $500 into Together and later want to switch to a gateway for fallback, that balance sits idle. Mitigate by keeping prepaid wallets small and topping up via API.
Metered billing discipline
Pure metered billing demands tight instrumentation. You must emit per-request token counts to your own ledger. Without that, a prompt regression can 10x your bill before the monthly invoice arrives.
Decisive takeaway
The answer to “do LLM API credits expire” splits cleanly: promotional grants always expire (30–90 days); prepaid wallets from Together or OpenRouter do not; and the major first-party APIs (OpenAI paid, Anthropic, Vertex post-trial, Azure) are metered with no credits at all. For production systems, default to metered billing or a non-expiring wallet accessed through a gateway with fallback. Treat any expiring credit as a time-boxed experiment budget, never as infrastructure.