Is Supabase Down? Developer's Guide to Handling Outages (2026)

TLDR: Check if Supabase is down at apistatuscheck.com/api/supabase. This guide covers how to detect Supabase outages affecting your database, auth, and storage, plus offline-first patterns to keep your app functional.

TLDR: When Supabase goes down, check status.supabase.com and apistatuscheck.com/api/supabase. Build resilience with connection pooling, database connection retries, client-side caching, and fallback auth providers so your app degrades gracefully instead of going completely offline during outages.

Your app just stopped loading data. Auth is failing. Realtime subscriptions dropped. Your users are refreshing and nothing's happening. Supabase might be down — and since it's your database, auth provider, storage layer, and realtime engine all in one, a Supabase outage can take your entire app offline.

Here's how to confirm it's Supabase, respond immediately, and architect your app so the next outage doesn't take everything down with it.

Is Supabase Actually Down Right Now?

Before you start debugging your queries, confirm it's a Supabase issue:

1. API Status Check — Supabase — Independent monitoring with response time history
2. Is Supabase Down? — Quick status check with 24h timeline
3. Supabase Official Status — Supabase's Statuspage (sometimes delayed)
4. Downdetector — Supabase — Community-reported outages

What Supabase Outages Look Like

Supabase isn't a single service — it's a platform built on several components. Knowing which piece is failing changes your response:

Component	Symptoms	Impact
Database (Postgres)	Queries timeout, ECONNREFUSED, 57P03 errors	Full data layer down
Auth (GoTrue)	Login/signup fails, JWT refresh errors	Users locked out
Realtime	Subscriptions drop, no live updates	Features degrade
Storage	File uploads/downloads fail, 5xx on objects	Media broken
Edge Functions	502/503 on function invocations	Serverless logic down
Dashboard/API	Can't manage projects, REST API errors	Development blocked
PostgREST	REST queries return 500, schema cache stale	API layer broken

Key insight: Supabase runs your Postgres in a specific region. Outages are often region-specific — your ap-southeast-1 project can be down while us-east-1 is fine. Always check YOUR project's region status.

Recent Supabase Incidents

• Jan 2026 — Elevated 5xx errors and high response times in ap-southeast-1 region. Other regions remained healthy.
• Nov 2025 — Brief service warning lasting ~1 hour affecting dashboard and management API.
• Regular maintenance — Supabase schedules maintenance windows (typically 02:00-03:00 UTC) for platform stability updates.

Architecture Patterns for Supabase Resilience

Read Replicas for Critical Reads

If you're on Supabase Pro or higher, enable read replicas. Your primary can go down while reads continue:

// Primary for writes
const primaryClient = createClient(PRIMARY_URL, ANON_KEY)

// Read replica for queries
const readClient = createClient(READ_REPLICA_URL, ANON_KEY)

async function resilientQuery(table: string, query: string) {
  try {
    // Try read replica first (lower load)
    return await readClient.from(table).select(query)
  } catch {
    // Fall back to primary
    return await primaryClient.from(table).select(query)
  }
}

Cache Critical Data

Don't hit Supabase for data that rarely changes:

import { LRUCache } from 'lru-cache'

const cache = new LRUCache<string, any>({
  max: 500,
  ttl: 1000 * 60 * 5, // 5 minutes
})

async function getCachedQuery(key: string, queryFn: () => Promise<any>) {
  const cached = cache.get(key)
  if (cached) return cached
  
  try {
    const result = await queryFn()
    if (result.data) cache.set(key, result)
    return result
  } catch (error) {
    // Return stale data if Supabase is down
    const stale = cache.get(key, { allowStale: true })
    if (stale) {
      console.warn(`Serving stale data for ${key} — Supabase may be down`)
      return stale
    }
    throw error
  }
}

// Usage
const products = await getCachedQuery('featured-products', () =>
  supabase.from('products').select('*').eq('featured', true)
)

Realtime Reconnection Strategy

Supabase Realtime channels can drop during partial outages. Don't just subscribe and forget:

function createResilientChannel(channelName: string, table: string, callback: (payload: any) => void) {
  let channel: any = null
  let reconnectTimer: any = null
  
  function connect() {
    channel = supabase
      .channel(channelName)
      .on('postgres_changes', { event: '*', schema: 'public', table }, callback)
      .subscribe((status: string) => {
        if (status === 'SUBSCRIBED') {
          console.log(`Realtime connected: ${channelName}`)
          clearTimeout(reconnectTimer)
        }
        if (status === 'CLOSED' || status === 'CHANNEL_ERROR') {
          console.warn(`Realtime lost: ${channelName}, reconnecting in 5s...`)
          reconnectTimer = setTimeout(connect, 5000)
        }
      })
  }
  
  connect()
  return () => {
    clearTimeout(reconnectTimer)
    channel?.unsubscribe()
  }
}

---

Monitoring Supabase Proactively

Don't wait for users to tell you Supabase is down. Set up monitoring:

Health Check Endpoint

Add a /api/health route that tests Supabase connectivity:

// Next.js API route: /api/health
export async function GET() {
  const checks = {
    database: false,
    auth: false,
    storage: false,
    timestamp: new Date().toISOString(),
  }
  
  try {
    // Test database
    const { error: dbError } = await supabase.from('_health').select('count').single()
    checks.database = !dbError
  } catch { checks.database = false }
  
  try {
    // Test auth service
    const res = await fetch(`${process.env.NEXT_PUBLIC_SUPABASE_URL}/auth/v1/health`)
    checks.auth = res.ok
  } catch { checks.auth = false }
  
  try {
    // Test storage
    const { error: storageError } = await supabase.storage.from('public').list('', { limit: 1 })
    checks.storage = !storageError
  } catch { checks.storage = false }
  
  const allHealthy = Object.values(checks).every(v => v === true || typeof v === 'string')
  
  return Response.json(checks, { status: allHealthy ? 200 : 503 })
}

Set Up Alerts

1. API Status Check — Get notified via Discord/Slack when Supabase status changes
2. Supabase Dashboard Alerts — Built-in alerts for database CPU, memory, and connection limits
3. Custom monitoring — Hit your /api/health endpoint every minute with UptimeRobot or similar

---

Common Supabase Error Codes

Error	Meaning	Fix
PGRST301	JWT expired	Refresh auth token
PGRST204	Column not found	Check schema cache, refresh PostgREST
53300	Too many connections	Use connection pooler (port 6543)
57P03	Cannot connect	Database restarting or region outage
42501	Permission denied	Check RLS policies
ECONNREFUSED	Connection refused	Full outage or wrong connection string
FetchError	Network error	Check DNS, firewall, or platform status

---

Supabase vs. Self-Hosted Postgres: The Tradeoff

When Supabase goes down, some teams consider self-hosting. Here's the real tradeoff:

Supabase managed:

• ✅ They handle backups, scaling, security patches
• ✅ Built-in auth, storage, realtime, edge functions
• ❌ You're dependent on their infrastructure
• ❌ Regional outages affect all your projects in that region

Self-hosted Postgres:

• ✅ Full control over uptime
• ✅ Can run multi-region yourself
• ❌ You're now the DBA, security team, and ops team
• ❌ No built-in auth, storage, or realtime

The pragmatic approach: Use Supabase but architect for resilience. Cache aggressively, implement retry logic, and have a read-only fallback mode. The 99.9% uptime you get from a managed service beats the 99.99% you theoretically get from self-hosting but spend all your time maintaining.

---

Get Notified Before Your Users Do

Stop finding out about Supabase outages from angry user reports:

1. Bookmark apistatuscheck.com/api/supabase for real-time status
2. Set up Discord/Slack alerts via API Status Check integrations
3. Subscribe to status.supabase.com for official updates
4. Add the health check endpoint above to your monitoring stack

Supabase outages are rare but impactful. The teams that handle them well aren't the ones with the best monitoring — they're the ones whose apps keep working anyway.

---

API Status Check monitors Supabase and 100+ other APIs in real-time. Set up free alerts at apistatuscheck.com.