API Uptime in 2026: Who's Most Reliable?

API downtime costs money. Stripe goes down, you can't take payments. Auth0 goes down, users can't log in. AWS goes down, and half the internet goes with it. Here's who's most reliable, how to measure it, and how to build resilience into your integrations.

Uptime Benchmarks

What "Five Nines" Means

Uptime	Downtime/Year	Downtime/Month	Realistic?
99%	3.65 days	7.3 hours	Unacceptable for production
99.9%	8.77 hours	43.8 minutes	Minimum for business APIs
99.95%	4.38 hours	21.9 minutes	Good
99.99%	52.6 minutes	4.38 minutes	Excellent
99.999%	5.26 minutes	26.3 seconds	Marketing claim (rarely real)

Reliability by Category

Payments (Business Critical)

Provider	Published SLA	Observed Uptime (2025)	Notable Incidents
Stripe	99.99%	~99.97%	Payment delays, dashboard outages
PayPal	99.95%	~99.9%	Checkout failures, settlement delays
Square	99.95%	~99.95%	Minor API latency spikes
Adyen	99.99%	~99.98%	Regional outages

Authentication

Provider	Published SLA	Observed Reliability
Auth0	99.99% (Enterprise)	Generally good, occasional login delays
Clerk	99.99%	Good track record
Firebase Auth	No published SLA	Tied to Google Cloud reliability
Okta	99.99%	High-profile incidents in 2024-2025

Cloud Infrastructure

Provider	Compute SLA	Observed	Impact of Outages
AWS	99.99% (per region)	~99.95%	Cascading — takes down many services
GCP	99.95-99.99%	~99.97%	Significant but less cascade
Azure	99.95-99.99%	~99.95%	Enterprise-impacting
Cloudflare	100% SLA (Enterprise)	~99.99%	Wide blast radius (CDN + DNS)

AI APIs

Provider	Published SLA	Observed Reliability
OpenAI	No public SLA	Variable — rate limits, capacity issues
Anthropic	No public SLA	Generally reliable, less capacity pressure
Google Gemini	99.9% (Cloud)	Tied to GCP reliability
Groq	No public SLA	Good for inference speed, capacity limits

How to Measure API Reliability

Key Metrics

Metric	What It Measures	Target
Uptime	Is the API responding?	>99.9%
Latency (P50)	Median response time	<200ms
Latency (P99)	Tail latency	<1s
Error rate	% of requests returning 5xx	<0.1%
Throughput	Requests per second at peak	Depends on SLA
MTTR	Mean time to recovery	<30 minutes
MTTD	Mean time to detect	<5 minutes

Monitoring Setup

// Simple API health check
async function checkApiHealth(name: string, url: string) {
  const start = Date.now();
  try {
    const res = await fetch(url, {
      signal: AbortSignal.timeout(5000),
    });
    const latency = Date.now() - start;

    return {
      name,
      status: res.ok ? 'up' : 'degraded',
      latency,
      statusCode: res.status,
      timestamp: new Date().toISOString(),
    };
  } catch (error) {
    return {
      name,
      status: 'down',
      latency: Date.now() - start,
      error: error.message,
      timestamp: new Date().toISOString(),
    };
  }
}

// Monitor critical APIs
const apis = [
  { name: 'Stripe', url: 'https://api.stripe.com/v1/charges' },
  { name: 'Auth0', url: 'https://YOUR_DOMAIN.auth0.com/authorize' },
  { name: 'OpenAI', url: 'https://api.openai.com/v1/models' },
];

Building Resilient Integrations

1. Circuit Breaker Pattern

class CircuitBreaker {
  private failures = 0;
  private lastFailure = 0;
  private state: 'closed' | 'open' | 'half-open' = 'closed';

  constructor(
    private threshold: number = 5,
    private timeout: number = 30000,
  ) {}

  async execute<T>(fn: () => Promise<T>, fallback?: () => Promise<T>): Promise<T> {
    if (this.state === 'open') {
      if (Date.now() - this.lastFailure > this.timeout) {
        this.state = 'half-open';
      } else if (fallback) {
        return fallback();
      } else {
        throw new Error('Circuit breaker is open');
      }
    }

    try {
      const result = await fn();
      this.failures = 0;
      this.state = 'closed';
      return result;
    } catch (error) {
      this.failures++;
      this.lastFailure = Date.now();
      if (this.failures >= this.threshold) {
        this.state = 'open';
      }
      if (fallback) return fallback();
      throw error;
    }
  }
}

const paymentCircuit = new CircuitBreaker(3, 60000);

await paymentCircuit.execute(
  () => stripe.charges.create({ amount: 2000, currency: 'usd' }),
  () => queuePaymentForRetry({ amount: 2000, currency: 'usd' }),
);

2. Retry with Exponential Backoff

async function withRetry<T>(
  fn: () => Promise<T>,
  options: {
    maxRetries?: number;
    baseDelay?: number;
    maxDelay?: number;
    retryableErrors?: number[];
  } = {}
): Promise<T> {
  const {
    maxRetries = 3,
    baseDelay = 1000,
    maxDelay = 30000,
    retryableErrors = [429, 500, 502, 503, 504],
  } = options;

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error: any) {
      if (attempt === maxRetries) throw error;

      const statusCode = error.status || error.statusCode;
      if (statusCode && !retryableErrors.includes(statusCode)) throw error;

      const delay = Math.min(
        baseDelay * Math.pow(2, attempt) + Math.random() * 1000,
        maxDelay
      );
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }

  throw new Error('Unreachable');
}

3. Multi-Provider Failover

const aiProviders = [
  { name: 'anthropic', fn: () => callAnthropic(prompt) },
  { name: 'openai', fn: () => callOpenAI(prompt) },
  { name: 'google', fn: () => callGemini(prompt) },
];

async function aiWithFailover(prompt: string) {
  for (const provider of aiProviders) {
    try {
      return await provider.fn();
    } catch (error) {
      console.warn(`${provider.name} failed, trying next...`);
    }
  }
  throw new Error('All AI providers failed');
}

4. Graceful Degradation

async function getProductRecommendations(userId: string) {
  try {
    // Try AI-powered recommendations
    return await aiRecommendations(userId);
  } catch {
    try {
      // Fallback: popularity-based
      return await getPopularProducts();
    } catch {
      // Final fallback: static list
      return DEFAULT_PRODUCTS;
    }
  }
}

Status Page Best Practices

For API Providers

A good status page includes:

Element	Why
Real-time status per service	Users know which part is affected
Historical uptime (90 days)	Builds trust
Incident timeline	Shows response speed
Subscription notifications	Email/webhook alerts
API endpoint for status	Programmatic monitoring

Best status pages: Stripe (status.stripe.com), Cloudflare, GitHub, Vercel.

For API Consumers

Don't just check the status page — monitor yourself:

• Status pages can be delayed (5-15 min lag)
• Some issues affect your region/use case but not others
• Partial degradation may not trigger status page updates

Common Mistakes

Mistake	Impact	Fix
No monitoring on third-party APIs	Don't know it's down until users report	Monitor all critical API dependencies
Trusting the status page alone	Delayed updates, partial outages missed	Run your own health checks
No retry logic	One failed request = failed user action	Implement retry with backoff
Same retry for all errors	Retrying 400s wastes time	Only retry 429 and 5xx
No fallback plan	Vendor outage = your outage	Define degraded mode for each dependency
No SLA tracking	Can't hold vendors accountable	Log uptime, latency, error rates

---

Check API reliability ratings on APIScout — we track uptime, latency, and incident history for hundreds of APIs.