LLM API Outages in 2026: 90 Days of Data

Every app built on a hosted model inherits its provider's bad days, and the only public record of those days is a status page that each provider writes its own way, with its own idea of what counts as an incident. The numbers most people quote are also getting old: IsDown's December 2025 report, still cited in Vercel's guide to AI gateways, counted 22 OpenAI incidents and about 182.7 hours of incident time in a single month.

We read 12 LLM provider status pages and pulled every incident they posted in the 90 days from July 14 to October 11, 2026. OpenAI's model APIs had an incident open for 72.7 hours and Anthropic's Claude API for 76.5 hours, but the two were in an incident at the same moment for only 36 minutes, and in both of those stretches the two incidents hit different features. The full dataset is a free CSV of 459 incidents.

Key Findings

• OpenAI posted 109 incidents across all its products from July 14 to October 11, 2026. Twenty touched its model APIs, which had an incident open for 72.7 hours, 3.4% of the 2,160 hours in the window.
• Anthropic posted 82 incidents in the same 90 days. Sixty touched the Claude API, which had an incident open for 76.5 hours (3.5%). Anthropic's API incidents were shorter, with a median of 51 minutes against OpenAI's 124.
• OpenAI and Anthropic API incidents overlapped for 36 minutes in total, across two stretches on July 21 and October 6, 2026.
• Google's Gemini API status page listed 2 API incidents in 90 days, Together AI listed none, and Fireworks AI listed 210, nearly all of them automated per-model alerts. Incident counts measure posting policy as much as reliability.
• 49% of OpenAI and Anthropic API incidents started on a weekday between 9 AM and 5 PM Eastern, a slice that covers 24% of the week.

How We Counted Incidents From 12 Status Pages

The window runs from July 14, 2026 at 00:00 UTC to October 12 at 00:00 UTC, and every page was read on October 12. It is 90 days because that is all OpenAI's page keeps: it runs on incident.io with a 90-day history window, as do the pages for Groq, Cohere, Perplexity and Fireworks AI. Anthropic and Cerebras use Atlassian Statuspage, and Google publishes the Gemini API's status on Google AI Studio. The status pages for xAI and Mistral returned Cloudflare bot checks to our automated requests, so neither is in the data.

An API incident is one the provider attached to a model API component: OpenAI's APIs group (Chat Completions, Responses, Embeddings, Batch, Realtime and the rest) minus the dashboard Login component, Anthropic's Claude API (api.anthropic.com) component, and Google's API and Multimodal Live API components. Four incidents with no component listed were classified from their text, as the CSV's note column records. ChatGPT, claude.ai, Claude Code, Codex, billing and support incidents count as incidents but not as API incidents.

Hours are the time the API component itself was marked degraded or worse, from the start time the provider reported to the update that restored it. When an incident was reopened and resolved a second time, we used the first resolution. Overlapping incidents from one provider are merged, so an hour with two open incidents counts once. Short error spikes nobody declared are invisible here.

OpenAI, Anthropic and Gemini Side by Side

The two biggest model APIs ended the 90 days within 4 hours of each other on API incident time, and got there in opposite ways.

Anthropic usually names the affected model in the title ("Elevated errors on Claude Sonnet 5", "Elevated errors for Claude Opus 4.8"), so it posted three times as many API incidents as OpenAI, each one shorter. OpenAI posts fewer and leaves them open longer: "Elevated latency in the Responses API" stayed open for 20.6 hours from the evening of August 31, and "Errors processing large PDFs in the Responses API" for 12.8 hours on October 6.

Severity points the other way. Anthropic marked the Claude API as a major outage 3 times and a partial outage 23 times, including "Elevated errors across all models" on July 29, a 2.5-hour major outage. OpenAI's API components never went past partial outage, which they reached 3 times, and 15 of its 20 API incidents were marked degraded performance.

Neither page's uptime figure lines up with those hours. On October 12, OpenAI's status page showed 99.95% uptime for its APIs group over 90 days, while Claude's status page showed 99.54% for the Claude API, though their API incident hours differ by less than 4. The percentages come from different status-page software applied to different component lists, so compare incident timelines, not percentages.

Anthropic's count also fell fast: 31 API incidents in the last 18 days of July, 17 in August, 8 in September and 4 in the first 11 days of October, against OpenAI's 8, 3, 7 and 2.

The 36 Minutes OpenAI and Anthropic Overlapped

In 90 days, OpenAI's and Anthropic's APIs had an incident open at the same moment twice, for 36 minutes in total, and neither stretch hit the same kind of request on both sides.

On July 21, 2026, from 9:04 to 9:22 AM ET, OpenAI's image generation incident had reached its Images API while Anthropic reported elevated errors on Claude Haiku 4.5. On October 6, from 8:24 to 8:43 AM ET, OpenAI's Responses API was failing on large PDFs while Anthropic reported elevated errors for Claude Opus 5.5. By the status pages' own account, a plain text request had a healthy provider to fail over to during every minute of the 90 days.

Gemini's overlaps look longer on paper, 230 minutes with OpenAI and 146 with Anthropic, but every one involves either the 45.2-hour Batch API delay that began September 14 or the voice-cloning failure on October 1, and neither touches a real-time text request.

Incident Counts Measure Posting Policy, Not Reliability

The other providers that answered show how far posting habits diverge.

Counts exclude a test incident and a migration notice on Perplexity's page and a planned maintenance on Groq's. Fireworks AI posted 52 times as many incidents as Google's Gemini API page, mostly automated alerts about a single serverless model, which does not make it 52 times less reliable. Together AI posted nothing at all, yet its own Better Stack monitors show Qwen3.8-2.4T-A95B at 99.061% uptime over 90 days.

A raw incident count rewards the provider that posts least. The Gemini page is also explicit about who gets protected first: "Free-tier requests use sheddable capacity, while billed-tier requests are protected by critical priority."

When Incidents Start: Half Land in the US Workday

Of the 80 OpenAI and Anthropic API incidents, 39 (49%) started Monday to Friday between 9 AM and 5 PM Eastern. That slice covers 40 of the week's 168 hours, or 24%. Some of that skew is simply when engineers are at their desks to declare one. Either way, test your fallback during US business hours.

What This Means for Fallbacks

A retry with exponential backoff covers a few seconds of errors, not Anthropic's 51-minute median API incident or OpenAI's 124-minute one. Past the retry budget, the request has to go somewhere else.

Fall back across providers, not only across models. Anthropic's July 29 major outage hit all models for 2.5 hours, so a fallback from Claude Opus to Claude Sonnet would have failed along with it, while a fallback to OpenAI would not.

Route by feature, too. In every overlap, at least one side was an image, PDF, batch or voice-cloning problem rather than plain text. If you depend on one of those, give it its own fallback and its own health check, and put a deadline on batch jobs so a 45-hour delay does not pass silently.

You do not have to write the failover by hand. Vercel AI Gateway takes a models array in providerOptions.gateway and tries each model in order, OpenRouter's models parameter does the same, and LiteLLM accepts a fallbacks list per model. Our LLM gateway comparison covers the tradeoffs.

How to Catch What a Status Page Never Posts

A status page shows only what the provider declares, so the short spikes behind your own 500 errors may never appear on it. Upptime, an MIT-licensed monitor with 17,178 GitHub stars as of October 12, 2026, runs your own checks from GitHub Actions every 5 minutes, the shortest schedule Actions allows. It opens a GitHub Issue when a check fails, closes it on recovery and publishes a status page on GitHub Pages. This .upptimerc.yml checks both APIs with keys kept in repository secrets:

yaml
Copy
secrets:
  - OPENAI_API_KEY
  - ANTHROPIC_API_KEY

sites:
  - name: OpenAI API
    url: https://api.openai.com/v1/models
    headers:
      - "Authorization: Bearer $OPENAI_API_KEY"
    maxResponseTime: 5000
  - name: Claude API
    url: https://api.anthropic.com/v1/models
    headers:
      - "x-api-key: $ANTHROPIC_API_KEY"
      - "anthropic-version: 2023-06-01"
    maxResponseTime: 5000

A model-list call spends no tokens but only proves the API answers. To catch per-model errors like the ones Anthropic posts, change an entry to method: POST with a one-token request to the model you call.

Check the Numbers Yourself

The CSV has one row per incident, with UTC times, the API impact windows, severity, components, our classification note and a link to the original. This script merges each provider's windows and prints the overlaps:

Python
Copy
import csv, sys
from datetime import datetime
from itertools import combinations

def merge(spans):
    out = []
    for a, b in sorted(spans):
        if out and a <= out[-1][1]:
            out[-1][1] = max(out[-1][1], b)
        else:
            out.append([a, b])
    return out

def hours(spans):
    return sum((b - a).total_seconds() for a, b in spans) / 3600

windows = {}
for row in csv.DictReader(open(sys.argv[1])):
    for w in filter(None, row["api_windows_utc"].split(" | ")):
        a, b = (datetime.fromisoformat(t) for t in w.split("/"))
        windows.setdefault(row["provider"], []).append((a, b))

merged = {p: merge(s) for p, s in windows.items()}
for p in ["OpenAI", "Anthropic", "Google Gemini API"]:
    print(f"{p:18} {hours(merged[p]):6.1f} h with an API incident open")
for x, y in combinations(["OpenAI", "Anthropic", "Google Gemini API"], 2):
    both = [(max(a, c), min(b, d)) for a, b in merged[x] for c, d in merged[y] if max(a, c) < min(b, d)]
    print(f"{x} + {y}: {hours(both) * 60:.0f} min at the same time")

Running it with Python 3.13 on the published file prints:

text
Copy
$ python3 overlap.py llm-api-incidents-2026-10.csv
OpenAI               72.7 h with an API incident open
Anthropic            76.5 h with an API incident open
Google Gemini API    48.0 h with an API incident open
OpenAI + Anthropic: 36 min at the same time
OpenAI + Google Gemini API: 230 min at the same time
Anthropic + Google Gemini API: 146 min at the same time

To drop an incident you classify differently, read the original through its url column, clear its api_windows_utc cell and rerun the script.

Verdict: What to Do With These Numbers

• One provider, no fallback: plan for 73 to 77 hours every 90 days with an API incident open, about 3.5% of the time, and add a second provider before you tune retries.
• Already behind a gateway: pair OpenAI and Anthropic. They overlapped for 36 minutes in 90 days, so either covers the other for plain text.
• Batch, PDF, image or voice workloads: this is where the overlaps happened. Give each its own fallback and a deadline check.
• Comparing vendors: ignore incident counts and uptime percentages. Compare hours on the components you call.

Conclusion

Ninety days of status pages put OpenAI and Anthropic within 4 hours of each other, each with an API incident open about 3.5% of the time, and the two overlapped for 36 minutes, never on the same kind of request. Incident counts mostly measure how a provider posts. The answer to an LLM outage is a second provider behind a gateway and a health check you run yourself, not a longer retry loop. The CSV is free to rerun, check and cite.

Related DevToolLab Tools

• Uptime SLA Calculator - turn a page's 99.95% or 99.54% into allowed minutes of downtime per month before you write a fallback budget.
• Exponential Backoff Calculator - see how many seconds a retry schedule actually covers, and why it cannot outlast a 51-minute incident.
• CSV Viewer - open the 459-row incident dataset in your browser and filter it by provider or by the api_incident column.
• Latency Percentile Calculator - compute p95 and p99 from your own request logs, since a "degraded performance" incident often shows up as latency before errors.

Related Guides

• Best LLM Gateways and API Routers in 2026
• OpenRouter: One Model, 33 Providers
• OpenAI Rate Limits in Python: Fix 429s
• Best Uptime Monitoring Tools in 2026