Is Supabase Down? How to Check Supabase Status in Real-Time

Is Supabase Down? How to Check Supabase Status in Real-Time

Quick Answer: To check if Supabase is down, visit apistatuscheck.com/api/supabase for real-time monitoring, or check the official status.supabase.com page. Common signs include database connection failures, authentication errors, Edge Functions timeouts, Realtime disconnections, and Storage upload failures.

When your Supabase-powered application suddenly stops responding, every second of downtime impacts your users and revenue. Supabase provides backend infrastructure for thousands of applications worldwide—from authentication and databases to real-time subscriptions and file storage. Whether you're seeing database connection errors, auth failures, or realtime disconnections, knowing how to quickly verify Supabase's operational status can save you hours of debugging and help you communicate effectively with your users.

How to Check Supabase Status in Real-Time

1. API Status Check (Fastest Method)

The quickest way to verify Supabase's operational status is through apistatuscheck.com/api/supabase. This real-time monitoring service:

  • Tests actual API endpoints every 60 seconds
  • Shows response times and latency trends
  • Tracks historical uptime over 30/60/90 days
  • Provides instant alerts when issues are detected
  • Monitors multiple regions and service components

Unlike status pages that rely on manual updates, API Status Check performs active health checks against Supabase's production endpoints, giving you the most accurate real-time picture of service availability across all critical services.

2. Official Supabase Status Page

Supabase maintains status.supabase.com as their official communication channel for service incidents. The page displays:

  • Current operational status for all services
  • Active incidents and investigations
  • Scheduled maintenance windows
  • Historical incident reports
  • Component-specific status (Database, Auth, Storage, Realtime, Edge Functions)

Pro tip: Subscribe to status updates via email or webhook on the status page to receive immediate notifications when incidents occur.

3. Check Your Project Dashboard

If the Supabase Dashboard at app.supabase.com is loading slowly or showing errors, this often indicates broader infrastructure issues. Pay attention to:

  • Login failures or timeouts
  • Table editor loading errors
  • SQL query execution failures
  • API key management access issues
  • Slow or non-responsive project settings

4. Test API Endpoints Directly

For developers, making a test API call can quickly confirm connectivity:

# Test REST API
curl https://YOUR_PROJECT.supabase.co/rest/v1/YOUR_TABLE \
  -H "apikey: YOUR_ANON_KEY" \
  -H "Authorization: Bearer YOUR_ANON_KEY"

# Test Auth endpoint
curl https://YOUR_PROJECT.supabase.co/auth/v1/health

# Test Storage
curl https://YOUR_PROJECT.supabase.co/storage/v1/bucket

Look for HTTP response codes outside the 2xx range, timeout errors, SSL/TLS handshake failures, or connection refused errors.

5. Monitor Supabase Community Channels

During widespread outages, the community often reports issues before official announcements:

Common Supabase Issues and How to Identify Them

Database Connection Failures

Symptoms:

  • Connection refused errors from PostgREST
  • Maximum number of connections reached errors
  • Query timeouts (queries that normally complete instantly hang)
  • FATAL: remaining connection slots reserved errors
  • 500/502/503 HTTP errors when querying tables

What it means: Database connection issues are among the most critical Supabase problems. They can stem from:

  • Overloaded database instances during high traffic
  • Infrastructure issues with PostgreSQL servers
  • Connection pooling exhaustion
  • Network connectivity problems between services

How to distinguish from your own issues: Test with a simple SELECT query on a small table. If even basic queries fail across different tables, the issue is likely with Supabase infrastructure rather than your specific database state or queries.

Authentication Service Issues

Common error patterns during Auth outages:

  • Error: Unable to validate JWT token
  • Auth session not found errors for valid sessions
  • Sign-up/sign-in requests timing out
  • Email confirmation links not working
  • OAuth provider redirects failing
  • Password reset emails not sending

Signs it's a Supabase Auth issue:

  • Multiple users reporting login failures simultaneously
  • Previously working auth flows suddenly broken
  • Issues persist across different authentication methods
  • Auth works in one region but not others

Auth service degradation often affects user sessions, causing mass logouts or preventing new logins. This creates immediate and visible impact for your users.

Edge Functions Timeouts

Indicators of Edge Functions issues:

  • Functions timing out after 30-60 seconds
  • Function invocation failed errors
  • Cold start times unusually high (>5 seconds)
  • Inconsistent execution (same function works sometimes, fails others)
  • Missing or delayed function logs

Edge Function error codes:

  • EDGE_FUNCTION_TIMEOUT - Function exceeded execution time limit
  • EDGE_FUNCTION_INVOCATION_FAILED - Function could not be invoked
  • Connection errors when functions try to access external APIs

Since Edge Functions often handle critical business logic (webhooks, scheduled tasks, API integrations), timeouts can break entire workflows.

Realtime Disconnections

Symptoms of Realtime service degradation:

  • WebSocket connections dropping repeatedly
  • Realtime channel error messages
  • Subscription events not arriving
  • Delayed event delivery (seconds to minutes late)
  • Presence feature not updating
  • Broadcast messages not received

What to look for in your console:

// Normal: Connected
{ status: 'SUBSCRIBED', channel: 'table-changes' }

// During outage: Disconnected/error
{ status: 'CHANNEL_ERROR', channel: 'table-changes' }
{ status: 'TIMED_OUT', channel: 'table-changes' }

Realtime issues are particularly problematic for collaborative applications, chat features, live dashboards, and multiplayer games where real-time updates are essential.

Storage Upload Failures

Common Storage service issues:

  • Upload requests timing out
  • Failed to upload file errors
  • 403 Forbidden errors for valid requests
  • Signed URLs not generating
  • Image transformations failing
  • Files uploading but not accessible via public URLs

Storage error patterns:

// Upload failures
StorageError: "The resource already exists"
StorageError: "Bucket not found"
StorageError: "Unable to process request"

// Access failures
404 errors on valid file URLs
403 errors despite correct RLS policies

Storage outages prevent users from uploading profile pictures, documents, images, and other media—directly impacting user experience and functionality.

The Real Impact When Supabase Goes Down

Application Unavailability

For applications built entirely on Supabase:

  • Complete service outage - Users cannot access core functionality
  • Data access blocked - All database reads and writes fail
  • Authentication broken - Users cannot login or maintain sessions
  • Real-time features dead - Live updates, chat, and collaborative features stop

A typical Supabase-powered SaaS experiencing 2 hours of downtime during peak hours could see:

  • 100% of active users impacted
  • Thousands of failed requests
  • Support ticket volume spike by 500%+
  • Immediate revenue impact for paid tiers

Failed User Operations

Every component failure cascades into user-facing problems:

Database down = Users cannot:

  • View their data or dashboards
  • Create, update, or delete records
  • Complete transactions or purchases
  • Access historical information

Auth down = Users cannot:

  • Login to existing accounts
  • Sign up for new accounts
  • Reset passwords
  • Verify email addresses
  • Use social login (Google, GitHub, etc.)

Storage down = Users cannot:

  • Upload profile pictures or avatars
  • Share files or documents
  • View existing uploaded media
  • Export or download content

Each failed operation creates frustration, support inquiries, and potential churn.

Real-Time Collaboration Breakdown

For applications depending on Supabase Realtime:

  • Multiplayer games: Players see stale state, desynced gameplay
  • Collaborative tools: Users overwrite each other's changes
  • Live chat: Messages don't deliver, presence status incorrect
  • Dashboards: Metrics frozen, alerts don't fire

The impact is immediate and visible, often causing users to abandon sessions entirely.

Developer Productivity Loss

When Supabase infrastructure fails:

  • Development and staging environments become unusable
  • CI/CD pipelines fail during database migrations
  • Testing blocked for features requiring backend
  • Team unable to debug or deploy fixes
  • Lost development time across engineering teams

For a 5-person development team earning $100/hour, a 4-hour outage equals $2,000 in lost productivity alone.

Data Consistency Risks

Partial outages create particularly thorny problems:

Scenario: Database writes succeed but Realtime events fail

  • Users see stale data in UI
  • Optimistic updates show incorrect state
  • Manual refresh required to see changes
  • Potential race conditions and conflicts

Scenario: Storage uploads succeed but database metadata writes fail

  • Orphaned files in storage buckets
  • Database records missing file references
  • Broken user experience (uploaded files "disappear")
  • Manual cleanup required post-outage

Reputation and Customer Trust

First-time user experience: New users encountering errors during trial or onboarding often never return. A single outage during a product demo or initial signup can permanently lose potential customers.

Enterprise concerns: For businesses evaluating Supabase for production use, outages raise questions about:

  • Infrastructure reliability
  • SLA guarantees
  • Disaster recovery capabilities
  • Whether to invest in Supabase or alternatives

Social media amplification: Frustrated users share experiences publicly:

  • "Tried to use [your app], keeps erroring out"
  • "Is anyone else having issues with [your app]?"
  • "Might switch to [competitor], too unreliable"

Each public complaint damages brand perception far beyond the actual downtime duration.

What to Do When Supabase Goes Down: Incident Response Playbook

1. Verify the Issue Scope

Before assuming Supabase is down:

  1. Check apistatuscheck.com/api/supabase for real-time status
  2. Test from different networks (your issue might be local/ISP-related)
  3. Check multiple Supabase services (database, auth, storage)
  4. Review your own application logs for error patterns
  5. Verify your Supabase project isn't paused (free tier inactivity)

Confirm it's a Supabase infrastructure issue when:

  • Multiple unrelated services failing simultaneously
  • Errors occur across different clients/locations
  • Official status page confirms incident
  • Community channels report widespread issues

2. Implement Graceful Degradation

Prioritize read-only mode:

// Detect Supabase connectivity
let supabaseHealthy = true;

async function checkSupabaseHealth() {
  try {
    await supabase.from('health_check').select('id').limit(1);
    supabaseHealthy = true;
  } catch (error) {
    supabaseHealthy = false;
    console.error('Supabase health check failed:', error);
  }
}

// Graceful degradation in components
if (!supabaseHealthy) {
  return <ReadOnlyMode 
    message="We're experiencing temporary backend issues. You can view data but cannot make changes right now." 
  />;
}

Cache aggressively:

  • Serve cached data when database queries fail
  • Store auth tokens and user data in localStorage
  • Pre-fetch critical data and keep in memory
  • Use stale-while-revalidate patterns

3. Queue Critical Operations

Implement offline queue for writes:

// Queue failed operations
const offlineQueue = [];

async function createRecord(data) {
  try {
    const { data: result, error } = await supabase
      .from('records')
      .insert(data);
    
    if (error) throw error;
    return result;
  } catch (error) {
    // Queue for retry
    offlineQueue.push({
      operation: 'insert',
      table: 'records',
      data: data,
      timestamp: Date.now()
    });
    
    // Notify user
    showNotification('Saved locally, will sync when connection restored');
  }
}

// Process queue when connection restored
async function processOfflineQueue() {
  while (offlineQueue.length > 0) {
    const op = offlineQueue[0];
    try {
      await supabase.from(op.table).insert(op.data);
      offlineQueue.shift(); // Remove from queue
    } catch (error) {
      break; // Stop if still failing
    }
  }
}

4. Activate Fallback Strategies

For Auth:

// Extend existing sessions during auth outage
const extendSession = () => {
  const session = localStorage.getItem('supabase.auth.token');
  if (session) {
    // Continue allowing access with existing token
    // even if refresh fails
    return session;
  }
};

For Database:

// Fallback to static data or alternative data source
if (databaseDown) {
  // Serve from Redis cache
  data = await redisCache.get('critical_data');
  
  // Or serve static fallback
  data = STATIC_FALLBACK_DATA;
}

For Storage:

// Temporarily use alternative storage
if (supabaseStorageDown) {
  // Upload to Cloudinary/S3 as temporary measure
  await cloudinary.upload(file);
  
  // Queue metadata for Supabase when recovered
  await queueStorageMetadata(fileInfo);
}

5. Communicate Proactively

User-facing communications:

// Show status banner
<StatusBanner severity="warning">
  We're experiencing temporary backend connectivity issues. 
  Some features may be unavailable. We're working to resolve this.
  <a href="/status">View status updates →</a>
</StatusBanner>

Multi-channel notifications:

  • Email: Send to all active users explaining the situation
  • In-app: Persistent banner or notification
  • Social media: Post updates on Twitter/X, Discord
  • Status page: Update your own status page if you have one

Template message:

"We're aware of service issues affecting [specific features]. The problem is related to our infrastructure provider's outage. We're monitoring the situation closely and will update you every 30 minutes. Your data is safe. Estimated recovery: [timeframe if known]."

6. Monitor and Document

Create incident log:

## Supabase Outage - 2026-02-04

**Timeline:**
- 14:32 UTC: First database connection errors detected
- 14:35 UTC: Confirmed widespread issue via status page
- 14:40 UTC: Enabled read-only mode, notified users
- 15:15 UTC: Partial recovery - auth working
- 15:45 UTC: Full service restored
- 16:00 UTC: All queued operations processed

**Impact:**
- Duration: 73 minutes
- Users affected: ~2,500 active users
- Failed operations: 3,847 database writes (all queued and recovered)
- Support tickets: 89

**Lessons learned:**
- Need better automated failover for auth
- Cache TTL should be longer for critical data
- Consider multi-region setup for redundancy

7. Post-Outage Recovery

Immediate actions once service restored:

  1. Process queued operations from your offline queue
  2. Verify data integrity - check for any corruption or missing data
  3. Monitor error rates - ensure everything is truly back to normal
  4. Process backlog - handle any accumulated webhooks, background jobs
  5. Thank users - send follow-up communication acknowledging the disruption
  6. Review monitoring - ensure alerting worked as expected

Follow-up analysis:

// Query error logs to assess impact
SELECT 
  DATE_TRUNC('minute', timestamp) as minute,
  COUNT(*) as error_count,
  error_type
FROM error_logs
WHERE timestamp BETWEEN '2026-02-04 14:30' AND '2026-02-04 16:00'
GROUP BY minute, error_type
ORDER BY minute;

8. Long-Term Resilience Improvements

After experiencing downtime, consider:

  1. Implement comprehensive monitoring

    • API Status Check for external monitoring
    • Internal health checks every 60 seconds
    • Alert on error rate spikes

  2. Add redundancy

    • Cache layer (Redis) for critical queries
    • CDN for static assets and frequently-accessed data
    • Alternative storage provider as fallback

  3. Improve offline capabilities

    • Local-first architecture with sync
    • Service worker for offline functionality
    • Better queue management for writes

  4. Review Supabase tier

    • Pro/Enterprise tiers offer better SLAs
    • Dedicated instances have fewer shared resource issues
    • Consider multi-region setup

  5. Disaster recovery plan

    • Regular backups (Supabase provides daily backups on Pro+)
    • Test restoration procedures
    • Document runbook for common scenarios

Frequently Asked Questions

How often does Supabase go down?

Supabase maintains strong uptime, typically exceeding 99.9% availability. Major platform-wide outages are relatively rare (2-4 times per year), though individual project issues or regional incidents may occur more frequently. The free tier may experience more disruptions than paid tiers due to shared resources. Most production applications on Pro or Enterprise plans experience minimal downtime.

What's the difference between Supabase status page and API Status Check?

The official Supabase status page (status.supabase.com) is manually updated by Supabase's engineering team during incidents, which can sometimes lag behind actual issues by several minutes. API Status Check performs automated health checks every 60 seconds against live endpoints, often detecting issues before they're officially reported. For comprehensive monitoring, use both: API Status Check for early detection, and the official status page for detailed incident information and ETAs.

Should I use Supabase free tier for production?

The free tier is excellent for development, prototypes, and low-traffic applications, but production apps should strongly consider Pro tier ($25/month) or higher. Key differences:

  • Free tier: Shared resources, project pauses after inactivity, no guaranteed SLA, limited support
  • Pro tier: Dedicated resources, no pausing, 99.9% uptime SLA, email support, daily backups
  • Enterprise: Custom SLA, priority support, dedicated infrastructure, multi-region options

For revenue-generating applications, the Pro tier cost is negligible compared to the risk of downtime.

Can I run Supabase self-hosted to avoid outages?

Yes, Supabase is fully open source and can be self-hosted using Docker. This gives you complete control but also means you're responsible for:

  • Infrastructure management and scaling
  • Security patches and updates
  • Backup and disaster recovery
  • Monitoring and incident response

Self-hosting makes sense for enterprises with strict compliance requirements or those with existing DevOps capabilities. For most startups and SMBs, managed Supabase offers better reliability than self-managed infrastructure.

How do I prevent data loss during Supabase outages?

To protect against data loss:

  1. Enable Supabase backups (included in Pro tier) - daily automated backups
  2. Implement application-level queueing - store failed writes locally and retry
  3. Use optimistic locking - prevent conflicts when recovering from outages
  4. Log all mutations - maintain audit trail of data changes
  5. Regular exports - periodically export critical data to external storage
  6. Test recovery procedures - practice restoring from backups

Supabase's PostgreSQL database is highly durable, so data loss from infrastructure issues is extremely rare. Most "data loss" scenarios are actually temporary write failures that can be recovered.

What are Supabase's SLA guarantees?

SLA commitments vary by tier:

  • Free tier: No SLA (best effort)
  • Pro tier: 99.9% uptime SLA
  • Enterprise tier: Custom SLA (can negotiate 99.95% or higher)

SLAs typically cover database availability and don't include scheduled maintenance windows. Read the full SLA terms at supabase.com/pricing for specifics on credits and exclusions.

Should I use Supabase Realtime or polling for critical data?

For critical operations, implement a hybrid approach:

Primary: Use Realtime subscriptions for instant updates Fallback: Include periodic polling (every 30-60 seconds) as backup

// Subscribe to realtime changes
const subscription = supabase
  .channel('table-changes')
  .on('postgres_changes', 
    { event: '*', schema: 'public', table: 'orders' },
    handleRealtimeUpdate
  )
  .subscribe();

// Polling fallback
setInterval(async () => {
  if (!realtimeHealthy) {
    const { data } = await supabase
      .from('orders')
      .select('*')
      .gt('updated_at', lastPollTime);
    handlePolledUpdates(data);
  }
}, 30000);

This ensures you never miss critical updates even during Realtime service degradation.

How can I monitor Supabase for my specific project?

Multi-layered monitoring provides the best coverage:

  1. External monitoring: API Status Check - monitors platform-wide availability
  2. Project-specific monitoring: Create health check endpoints in your app that test actual database queries, auth flows, and storage operations
  3. Client-side monitoring: Track error rates from your application using tools like Sentry or LogRocket
  4. Official alerts: Subscribe to status.supabase.com notifications
  5. Database metrics: Use Supabase Dashboard metrics for query performance and connection counts

Combine automated alerts with manual checks during critical business operations (product launches, major campaigns).

Stay Ahead of Supabase Outages

Don't let backend infrastructure issues catch you off guard. Subscribe to real-time Supabase monitoring and get notified instantly when issues are detected—before your users flood support channels.

API Status Check monitors Supabase 24/7 with:

  • 60-second health checks across all critical services
  • Instant alerts via email, Slack, Discord, or webhook
  • Historical uptime tracking and incident reports
  • Multi-API monitoring for your entire infrastructure stack

Also monitoring:

Start monitoring Supabase now →

Last updated: February 4, 2026. Supabase status information is provided in real-time based on active monitoring. For official incident reports, always refer to status.supabase.com.

Monitor Your APIs

Check the real-time status of 100+ popular APIs used by developers.

View API Status →