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

by API Status Check Team

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

Quick Answer: To check if PlanetScale is down, visit status.planetscale.com for official updates or use API Status Check's PlanetScale monitor for real-time status tracking and instant alerts when outages occur.

When your database connections suddenly timeout, deploy requests fail mysteriously, or branch schema migrations freeze mid-operation, the critical question is: "Is PlanetScale down, or is it just my database configuration?" For developers relying on PlanetScale's serverless MySQL platform to power production databases with non-blocking schema changes and database branching, quickly distinguishing between a platform-wide PlanetScale outage and a project-specific issue is essential for effective incident response.

This comprehensive guide covers everything you need to know about checking PlanetScale status, understanding common PlanetScale connection failures and migration errors, and responding effectively when PlanetScale experiences downtime.

How to Check PlanetScale Status Right Now

Official PlanetScale Status Page

The primary source for PlanetScale platform status is status.planetscale.com. This official status page provides:

  • Real-time incident reports across PlanetScale's infrastructure
  • Component-level status for Database Connections, Control Plane API, Deploy Requests, Branching, Console UI, and Vitess Query Engine
  • Historical incident timeline with root cause analyses
  • Scheduled maintenance notifications that may impact availability
  • Subscription options for email/SMS/Slack alerts

The PlanetScale status page uses standard severity indicators:

  • 🟢 Operational - All systems functioning normally
  • 🟡 Degraded Performance - Partial functionality or increased query latency
  • 🟠 Partial Outage - Some components, regions, or availability zones unavailable
  • 🔴 Major Outage - Widespread service disruption affecting database connectivity

API Status Check for Automated Monitoring

For developers who need programmatic access to PlanetScale status or want proactive automated alerts, API Status Check provides:

  • Real-time status API you can integrate into dashboards, monitoring tools, or CI/CD pipelines
  • Instant notifications via email, Slack, Discord, or webhook when PlanetScale goes down
  • Uptime tracking with historical outage data and incident patterns
  • Multi-service monitoring to detect correlated infrastructure issues

You can check PlanetScale status programmatically:

curl https://apistatuscheck.com/api/planetscale

This returns a JSON response with current status, recent incidents, and uptime metrics—perfect for integrating into your status dashboard or automated incident response workflows.

Community Indicators

Beyond official channels, developers often report PlanetScale issues on:

  • Twitter/X - Search for "planetscale down" or "planetscale status"
  • Reddit r/planetscale - Community discussions about ongoing problems
  • GitHub Discussions - PlanetScale community forum for platform issues
  • Hacker News - PlanetScale outages often discussed, especially after free tier removal
  • DownDetector - Crowdsourced outage reports and regional heat maps
  • Discord/Slack communities - Developer communities often report database issues early

While community reports aren't official, they often provide early warning signals before PlanetScale formally acknowledges an incident on their status page. Note: After PlanetScale removed their free tier in early 2024, many developers migrated to alternatives like Neon, Supabase, or Railway, which may affect community discussion volume.

Common PlanetScale Issues and Errors

Not every PlanetScale problem indicates a platform-wide outage. Understanding common error patterns helps you diagnose whether the issue is with PlanetScale's infrastructure or your specific database configuration.

Connection Timeout Errors

Error: Error: connect ETIMEDOUT, Can't reach database server, or Connection pool exhausted

Meaning: Your application can't establish or maintain connections to PlanetScale's MySQL servers.

Common Causes:

  • IP allowlist misconfigured - Application server IP not whitelisted in PlanetScale database settings
  • Connection string wrong - Incorrect host, username, password, or SSL parameters
  • Connection pool exhausted - Too many concurrent queries depleting available connections
  • Network/firewall blocking - Corporate firewall or VPC rules blocking MySQL port 3306
  • SSL/TLS certificate validation - Missing or expired SSL certificates preventing secure connections
  • Database sleeping - Database hibernated due to inactivity (less common on paid plans)
  • Region latency - High latency to PlanetScale region causing connection timeouts

During outages: Widespread connection timeouts across multiple databases and regions indicates PlanetScale's connection infrastructure experiencing issues.

Not a PlanetScale outage if: Only specific applications fail to connect while PlanetScale console shows database as active, or errors isolated to one IP range/network.

Deploy Request Failures

Error: Deploy request failed, Schema change rejected, or Deploy request timed out

Meaning: Your schema migration deploy request from development branch to production failed to complete.

Common Causes:

  • Schema conflicts - Breaking changes that conflict with existing production schema (dropped columns with data, incompatible ALTER TABLE operations)
  • Deploy queue backlog - Multiple concurrent deploy requests blocking each other
  • Safe migrations disabled - Attempting unsafe migrations without explicit confirmation
  • Foreign key violations - Schema changes violating referential integrity constraints
  • Vitess limitations - Schema changes not compatible with PlanetScale's Vitess-based architecture
  • Large table locks - Migration requiring table lock on massive table (millions/billions of rows)
  • Revert conflicts - Attempting to revert deployment that has subsequent dependent changes

During outages: Platform-wide deploy request failures across multiple users indicates PlanetScale's deployment orchestration service experiencing load or infrastructure problems.

Check: PlanetScale console deploy request logs for specific error messages and suggested fixes.

Schema Migration Errors

Error: Migration failed, Invalid DDL statement, or Schema validation error

Meaning: Your database schema changes contain incompatible or unsafe operations for PlanetScale's Vitess-powered MySQL.

Common Causes:

  • Unsupported DDL statements - RENAME TABLE, TRUNCATE TABLE, certain ALTER TABLE variants not supported by Vitess
  • Non-blocking schema change incompatibility - Operations requiring downtime on traditional MySQL but blocked by PlanetScale
  • Character set/collation conflicts - Incompatible character encoding changes
  • Index size limits - Creating indexes exceeding Vitess size constraints
  • Enum modifications - Changing ENUM values in unsafe ways
  • Temporal table operations - Operations on tables with temporal versioning not fully supported
  • Stored procedures/triggers - PlanetScale doesn't support stored procedures, triggers, or events

During outages: Widespread schema migration failures across different types of operations can indicate PlanetScale's schema validation or migration service issues.

Impact: Schema evolution blocked, preventing new features from deploying to production.

Branch Sync Issues

Error: Branch sync failed, Branch diverged, or Cannot create branch

Meaning: PlanetScale's database branching feature (similar to Git branches) experiencing synchronization problems.

Common Causes:

  • Schema drift - Development and production branches diverged beyond reconcilable point
  • Insufficient storage - Database storage quota exceeded, preventing branch creation
  • Parent branch deleted - Development branch's parent branch was removed
  • Concurrent modifications - Multiple developers making conflicting schema changes on same branch
  • Branch limit reached - Hit maximum number of concurrent branches for plan tier
  • Data seeding timeout - Branch creation with data copy taking too long
  • Backup restore conflict - Attempting to create branch while backup/restore operation in progress

During outages: Multiple users unable to create or sync branches indicates PlanetScale's branching infrastructure experiencing issues.

Not a PlanetScale outage if: Only specific branch operations fail while others succeed, or issue isolated to branches with extremely large datasets.

Boost Query Performance Quota Limits

Error: Query rejected - boost quota exceeded, Boost capacity unavailable, or Query timeout - boost disabled

Meaning: Your database exceeded boost query performance quota limits, causing slower query execution.

Common Causes:

  • Plan tier limits - Free tier (now removed) or Scaler plan hitting boost usage caps
  • Expensive queries - Unoptimized queries consuming excessive CPU/memory triggering quota limits
  • Missing indexes - Full table scans on large tables burning through boost budget
  • Traffic spikes - Sudden traffic surge exhausting monthly boost allocation
  • Background jobs - Large batch operations (reports, exports, migrations) consuming boost quota
  • N+1 query problems - ORM-generated queries creating thousands of database calls

During outages: Platform-wide boost quota enforcement errors across users on similar plans can indicate PlanetScale's resource allocation or metering service issues.

Impact: Query performance degrades significantly, API response times increase, user experience suffers.

Vitess Query Compatibility Issues

Error: Query syntax not supported, Vitess routing error, or Unsupported MySQL feature

Meaning: Your SQL queries use MySQL features not compatible with PlanetScale's Vitess-based architecture.

Common Causes:

  • Subqueries in certain contexts - Complex nested subqueries not optimized by Vitess query planner
  • Cross-shard queries - Queries spanning multiple Vitess shards without proper routing hints
  • Multi-table deletes - DELETE statements joining multiple tables
  • Temp table operations - Temporary table creation and manipulation
  • User-defined variables - @variable syntax not fully supported
  • Stored procedures - Calling stored procedures (PlanetScale doesn't support them)
  • Locking clauses - FOR UPDATE, LOCK IN SHARE MODE with certain query patterns

During outages: Queries that previously worked suddenly failing across multiple databases can indicate PlanetScale deploying Vitess version updates with regressions.

Not a PlanetScale outage if: Only newly introduced queries fail while existing production queries continue working.

Console UI Loading Issues

Error: Dashboard slow to load, showing errors, or completely unresponsive

Meaning: PlanetScale web console experiencing performance or availability problems.

Common Causes:

  • Browser cache corruption - Stale cached assets causing rendering issues
  • Network latency - Slow connection to PlanetScale console servers
  • Large database schemas - Console struggling to render schemas with thousands of tables/columns
  • Browser compatibility - Using unsupported or outdated browser
  • Ad blockers - Browser extensions interfering with console functionality
  • Session expiration - Authentication token expired requiring re-login

During outages: Multiple users reporting console unavailability indicates PlanetScale's web application infrastructure experiencing issues.

Impact: Cannot view query insights, manage branches, configure database settings, or monitor performance metrics via UI (CLI and database connections still work).

The Official PlanetScale Status Page Explained

PlanetScale's status page breaks down platform health by component:

Database Connections

The MySQL connection endpoint infrastructure. Issues here mean:

  • Queries timing out or returning connection errors
  • Connection pool exhaustion across multiple applications
  • SSL/TLS handshake failures
  • Regional connectivity problems
  • High connection latency or dropped connections

Control Plane API

PlanetScale's management API powering CLI and console. Outages affect:

  • Database creation/deletion operations blocked
  • Branch management via CLI failing
  • Schema introspection requests timing out
  • User/organization management unavailable
  • Integration webhooks not firing
  • Audit log retrieval failing

Deploy Requests

Schema deployment orchestration system. When degraded:

  • Deploy requests stuck in pending state
  • Schema migrations failing to apply
  • Deployment approval workflow broken
  • Revert operations timing out
  • Deploy queue processing delayed

Branching

Database branching infrastructure for development workflows. Issues include:

  • Cannot create new branches
  • Branch sync operations failing
  • Branch deletion hanging
  • Schema diff generation errors
  • Branch merging into production blocked

Console UI

The web-based PlanetScale dashboard. Outages prevent:

  • Viewing database metrics and query insights
  • Managing schema and deploy requests
  • Configuring database settings
  • Monitoring connection pool usage
  • Accessing audit logs

Vitess Query Engine

The underlying Vitess-powered query routing and execution layer. Problems affect:

  • Query performance degradation
  • Query routing errors for sharded databases
  • Schema change processing failures
  • Replication lag between database regions
  • Backup and restore operations

Impact When PlanetScale Goes Down

PlanetScale outages can have cascading effects across your entire application infrastructure:

1. Production Database Completely Inaccessible

The most immediate impact: your application can't read or write data. This means:

  • Customer-facing applications return 500 errors or database connection failures
  • User login/signup completely broken - authentication database unreachable
  • E-commerce transactions fail - orders can't be created or processed
  • Real-time features freeze - chat messages, notifications, live updates stop
  • API endpoints timeout waiting for database queries
  • Mobile apps crash trying to fetch data
  • User trust and business reputation severely damaged

2. Revenue Loss and Business Disruption

When your production database is down:

  • E-commerce sales halted - cannot process payments, orders, inventory updates
  • SaaS platform unusable - customers can't access paid features, triggering refund requests
  • Subscription renewals blocked - billing operations depending on database fail
  • Support ticket surge - customer complaints overwhelming support team
  • SLA breaches - contractual uptime commitments violated
  • Competitive disadvantage - customers evaluate switching to competitors with better reliability

3. Data Sync and Replication Disrupted

Database unavailability impacts dependent systems:

  • Data warehouse ETL jobs fail - Analytics pipelines broken, reports outdated
  • Third-party integrations broken - Webhooks, API syncs to Salesforce, HubSpot, Stripe fail
  • Microservices cascading failures - Services depending on shared PlanetScale database all fail
  • Cache invalidation blocked - Cannot update Redis/Memcached with fresh database state
  • Search index stale - Elasticsearch, Algolia, Typesense indexes can't sync latest data

4. Development and Deployment Completely Blocked

Engineering teams lose critical capabilities:

  • Deployments halted - CI/CD pipelines fail database migration steps
  • Schema changes blocked - Cannot evolve data model or fix production schema issues
  • Local development broken - Developers using PlanetScale branches can't run applications locally
  • Database branching unavailable - Cannot create feature branches for testing schema changes
  • Rollback impossible - Cannot revert bad schema deployments during incidents
  • Testing environments down - QA, staging databases unavailable

5. Long-Term Migration Consequences

Post-outage recovery and strategic shifts:

  • Migration to alternatives accelerates - Teams migrate to Neon, Supabase, Railway, or AWS RDS
  • Multi-database architecture - Organizations split data across multiple providers for redundancy
  • Self-hosted MySQL considered - Teams evaluate running own MySQL on AWS, GCP, or DigitalOcean
  • Free tier removal backlash - After 2024 free tier removal, outages trigger renewed criticism and churn
  • Vendor lock-in concerns - Vitess-specific features make migration more difficult

6. Customer Experience Severely Degraded

End users directly impacted by database downtime:

  • Data loss anxiety - Users worry if their work/data was saved before outage
  • Inconsistent state - Partial writes or reads creating data integrity issues
  • Lost productivity - Cannot access tools, documents, projects
  • Support channel flooding - Users overwhelming Twitter, email, chat with complaints
  • Brand damage - Social media backlash, negative reviews, Hacker News discussion
  • Churn risk - Enterprise customers reconsidering contracts during renewal

What to Do When PlanetScale Is Down

Immediate Response (First 15 Minutes)

1. Confirm the Outage Scope

  • Check status.planetscale.com for official incident acknowledgment
  • Verify via API Status Check for independent confirmation
  • Test database connections from multiple locations/IPs to rule out network issues
  • Query multiple databases/branches to determine if issue is database-specific or platform-wide
  • Check PlanetScale Twitter and community forums for reports

2. Communicate Proactively with Stakeholders

  • Update your status page (Statuspage.io, custom page) with current PlanetScale incident information
  • Notify users via email, push notifications, or in-app banner about database unavailability
  • Alert internal teams (support, sales, engineering, executive leadership) about incident severity and business impact
  • Set realistic expectations about resolution timeline based on PlanetScale status updates
  • Prepare customer communication for potential data inconsistency or lost transactions

3. Activate Fallback Database (if configured)

  • If you've implemented read replicas or failover database, switch traffic immediately
  • Promote read-only replica to primary (if using manual replication setup)
  • Redirect queries to cached data sources (Redis, CDN) for read operations
  • Queue write operations for retry when PlanetScale recovers
  • Monitor failover database performance and connection limits

Short-Term Mitigation (15-60 Minutes)

1. Implement Graceful Degradation

Reduce reliance on PlanetScale temporarily:

  • Enable maintenance mode - Display user-friendly "Under Maintenance" page
  • Switch to read-only mode - Serve cached data, disable all write operations
  • Static content fallback - Serve pre-rendered pages from CDN without database queries
  • Feature flags - Disable non-critical features requiring database access
  • Local caching - Extend cache TTL and serve stale data with warnings

2. Database Connection Pool Management

  • Increase connection timeout - Prevent premature connection failures if PlanetScale intermittently available
  • Reduce pool size - Lower maximum connections to avoid overwhelming PlanetScale when recovering
  • Circuit breaker pattern - Automatically stop database connection attempts after consecutive failures
  • Exponential backoff - Retry failed queries with increasing delays
  • Queue critical writes - Persist pending database operations to message queue (RabbitMQ, SQS) for later processing

3. Monitor Official Updates Closely

  • Subscribe to status.planetscale.com email/Slack notifications
  • Follow @PlanetScale on Twitter for real-time updates
  • Join PlanetScale Discord or community Slack for engineering team responses
  • Check incident post-mortems for estimated resolution time
  • Document timeline for potential service credit requests (especially for enterprise customers)

4. Assess and Document Business Impact

  • Calculate revenue loss - Lost transactions, failed subscriptions, cart abandonments
  • Count affected users - How many customers experienced errors or data issues
  • Log error rates - Application error logs, exception tracking (Sentry, Rollbar) showing database failures
  • Capture screenshots - Status page, error messages, monitoring dashboards
  • Track support tickets - Volume of customer complaints related to outage

Post-Outage Recovery Actions

1. Verify Complete Service Restoration

  • Test database connectivity from all application servers and regions
  • Run health checks - Execute test queries against production database
  • Monitor query latency - Ensure response times returned to normal baseline
  • Verify replication - Check all read replicas are in sync with primary
  • Process queued writes - Replay any operations queued during outage
  • Check schema deploy requests - Verify any pending migrations completed successfully

2. Handle Data Consistency Issues

  • Audit critical transactions - Verify payments, orders, user registrations completed
  • Check for partial writes - Identify transactions that failed mid-operation
  • Run data integrity checks - Verify foreign key relationships, constraints
  • Reconcile external systems - Ensure third-party integrations (Stripe, Salesforce) in sync with database
  • Notify affected users - Contact customers whose operations may have failed
  • Provide data export - Allow users to verify their data integrity post-recovery

3. Conduct Thorough Post-Mortem

  • Document complete timeline - When outage detected, PlanetScale updates, recovery time
  • Calculate total impact - Revenue lost, users affected, support costs
  • Identify response gaps - What could have been done faster or better
  • Request incident report from PlanetScale (especially for enterprise customers)
  • Evaluate service credits - Determine eligibility for SLA credits based on contract
  • Update runbooks - Document lessons learned for future PlanetScale incidents

Long-Term Prevention Strategies

1. Automated Status Monitoring and Alerting

Don't rely on manual status page checking:

  • Subscribe to API Status Check alerts for instant notifications via email, Slack, Discord, or webhook
  • Configure PagerDuty/Opsgenie integration to escalate PlanetScale outages to on-call engineers
  • Build internal status dashboard aggregating PlanetScale status with application health metrics
  • Set up correlation rules - Auto-create incidents when PlanetScale down AND application error rate spikes
  • Monitor connection pool metrics - Alert on connection exhaustion before total failure

2. Database Failover and Redundancy Architecture

Design for PlanetScale unavailability:

  • Multi-region deployment - Use PlanetScale read replicas across geographic regions
  • Read replica promotion - Automate promotion of read replica to primary during outages
  • Database proxy layer - Implement ProxySQL or HAProxy for connection pooling and failover
  • Cross-provider redundancy - Replicate critical data to backup database (Neon, AWS RDS, self-hosted MySQL)
  • Event sourcing pattern - Store all state changes as immutable events, reconstruct from event log if database lost

3. Caching and Query Optimization

Reduce database dependency for reads:

  • Aggressive caching - Cache frequently-accessed data in Redis, Memcached with longer TTL
  • CDN caching - Serve static and semi-static content from Cloudflare, Fastly, Vercel Edge
  • Application-level cache - In-memory caching of reference data, lookups, config
  • Materialized views - Pre-compute expensive queries and cache results
  • Stale-while-revalidate - Serve cached data even when slightly outdated during outages

4. Write Operation Resilience

Ensure critical writes survive outages:

  • Message queue for writes - Queue all database writes to RabbitMQ, AWS SQS, or Kafka
  • Transactional outbox pattern - Store writes locally first, sync to PlanetScale asynchronously
  • Idempotent operations - Design writes to be safely retried without duplication
  • Distributed transactions - Use SAGA pattern for multi-step operations spanning database and external services
  • Local-first architecture - Persist writes locally, sync to cloud when available

5. Migration and Multi-Database Strategy

Reduce PlanetScale dependency long-term:

  • Evaluate alternatives - Consider Neon (serverless Postgres), Supabase (open-source Firebase alternative), Railway (simple deployment)
  • Hybrid database approach - Use PlanetScale for transactional data, Postgres for analytics/reporting
  • Gradual migration plan - Move non-critical databases off PlanetScale first, monitor before migrating critical systems
  • Database abstraction layer - Use ORM (Prisma, TypeORM) to make switching databases easier
  • Self-hosted fallback - Maintain ability to export and run MySQL yourself on AWS, GCP, or DigitalOcean

6. Comprehensive Incident Response Runbooks

Document standard operating procedures:

  • PlanetScale outage detection - Automated checks, manual verification steps
  • Escalation tree - Who to notify at each severity level (engineer → manager → CTO → CEO)
  • Failover activation - Step-by-step for switching to backup database
  • Customer communication templates - Pre-written status updates for different outage types
  • Service restoration checklist - What to verify before declaring all-clear
  • Post-mortem template - Standard format for documenting incidents

7. Regular Disaster Recovery Testing

Practice makes perfect:

  • Simulate PlanetScale outages quarterly by blocking database connections at firewall level
  • Test failover procedures - Verify backup database promotion works correctly
  • Measure recovery time - Track how long full service restoration takes
  • Validate data integrity - Confirm no data loss during failover and recovery
  • Update documentation - Improve runbooks based on drill findings
  • Train team members - Ensure multiple engineers can execute recovery procedures

PlanetScale Status API Integration Examples

Integrate PlanetScale status monitoring into your infrastructure:

Node.js Health Check Endpoint

// Express.js API health check
import express from 'express';
import fetch from 'node-fetch';

const app = express();

app.get('/health', async (req, res) => {
  try {
    // Check PlanetScale status
    const psStatus = await fetch('https://apistatuscheck.com/api/planetscale');
    const psData = await psStatus.json();
    
    // Test actual database connection
    const dbHealth = await testDatabaseConnection();
    
    const health = {
      status: dbHealth && psData.status === 'operational' ? 'healthy' : 'unhealthy',
      timestamp: new Date().toISOString(),
      checks: {
        database: dbHealth ? 'up' : 'down',
        planetscale_platform: psData.status,
        latency_ms: dbHealth?.latency
      }
    };
    
    res.status(health.status === 'healthy' ? 200 : 503).json(health);
  } catch (error) {
    res.status(503).json({ status: 'unhealthy', error: error.message });
  }
});

async function testDatabaseConnection() {
  const start = Date.now();
  try {
    await db.query('SELECT 1');
    return { success: true, latency: Date.now() - start };
  } catch (error) {
    return false;
  }
}

app.listen(3000);

Python Monitoring with Alerts

import requests
import os
import time
from datetime import datetime

def check_planetscale_status():
    """Monitor PlanetScale status and send alerts"""
    try:
        response = requests.get('https://apistatuscheck.com/api/planetscale', timeout=10)
        data = response.json()
        
        status = data.get('status', 'unknown')
        timestamp = datetime.now().isoformat()
        
        # Log to file
        with open('planetscale-status.log', 'a') as f:
            f.write(f"{timestamp} | Status: {status}\n")
        
        # Alert if degraded or down
        if status not in ['operational', 'up']:
            send_alert(status, data.get('message', 'No details available'))
            
            # Activate failover if critical
            if status == 'down':
                activate_database_failover()
        
        return status
        
    except Exception as e:
        print(f"Error checking PlanetScale status: {e}")
        # Assume down if status check fails
        send_alert('unknown', f'Status check failed: {e}')
        return 'error'

def send_alert(status, message):
    """Send alert via Slack webhook"""
    webhook_url = os.environ.get('SLACK_WEBHOOK_URL')
    
    if webhook_url:
        payload = {
            'text': f'🚨 PlanetScale Status Alert',
            'blocks': [
                {
                    'type': 'section',
                    'text': {
                        'type': 'mrkdwn',
                        'text': f'*Status:* {status}\n*Details:* {message}\n*Time:* {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}'
                    }
                },
                {
                    'type': 'section',
                    'text': {
                        'type': 'mrkdwn',
                        'text': '<https://status.planetscale.com|View Official Status> | <https://apistatuscheck.com/blog/is-planetscale-down|Incident Runbook>'
                    }
                }
            ]
        }
        requests.post(webhook_url, json=payload)

def activate_database_failover():
    """Switch to backup database"""
    print("🔄 Activating database failover to backup...")
    # Your failover logic here
    # e.g., update connection pool to point to read replica
    # promote read replica to primary
    # update load balancer configuration

if __name__ == '__main__':
    while True:
        check_planetscale_status()
        time.sleep(300)  # Check every 5 minutes

Next.js Dashboard Integration

// app/api/status/planetscale/route.ts
import { NextResponse } from 'next/server';

export async function GET() {
  try {
    const response = await fetch('https://apistatuscheck.com/api/planetscale', {
      next: { revalidate: 60 } // Cache for 60 seconds
    });
    
    if (!response.ok) {
      throw new Error('Failed to fetch PlanetScale status');
    }
    
    const data = await response.json();
    
    return NextResponse.json({
      service: 'PlanetScale',
      status: data.status,
      uptime: data.uptime,
      lastIncident: data.lastIncident,
      timestamp: new Date().toISOString(),
      statusPageUrl: 'https://status.planetscale.com'
    });
  } catch (error) {
    return NextResponse.json({
      service: 'PlanetScale',
      status: 'unknown',
      error: error.message
    }, { status: 500 });
  }
}

// Component usage:
// import { useEffect, useState } from 'react';
// 
// export function PlanetScaleStatusBadge() {
//   const [status, setStatus] = useState('operational');
//   
//   useEffect(() => {
//     fetch('/api/status/planetscale')
//       .then(res => res.json())
//       .then(data => setStatus(data.status));
//   }, []);
//   
//   if (status !== 'operational') {
//     return <div className="status-alert">⚠️ Database experiencing issues</div>;
//   }
//   return null;
// }

React Status Banner Component

import { useEffect, useState } from 'react';

export function PlanetScaleStatusBanner() {
  const [status, setStatus] = useState<{
    state: 'operational' | 'degraded' | 'down';
    message?: string;
  }>({ state: 'operational' });

  useEffect(() => {
    const checkStatus = async () => {
      try {
        const response = await fetch('https://apistatuscheck.com/api/planetscale');
        const data = await response.json();
        setStatus({
          state: data.status,
          message: data.message
        });
      } catch (error) {
        setStatus({ state: 'down', message: 'Cannot verify database status' });
      }
    };

    checkStatus();
    const interval = setInterval(checkStatus, 2 * 60 * 1000); // Every 2 minutes
    return () => clearInterval(interval);
  }, []);

  if (status.state === 'operational') return null;

  const severityConfig = {
    degraded: {
      bg: 'bg-yellow-50 border-yellow-200',
      text: 'text-yellow-800',
      icon: '⚠️'
    },
    down: {
      bg: 'bg-red-50 border-red-200',
      text: 'text-red-800',
      icon: '🔴'
    }
  };

  const config = severityConfig[status.state];

  return (
    <div className={`border-l-4 p-4 ${config.bg}`}>
      <div className="flex items-center">
        <span className="text-2xl mr-3">{config.icon}</span>
        <div className="flex-1">
          <h3 className={`font-semibold ${config.text}`}>
            PlanetScale Database Issues Detected
          </h3>
          <p className={`text-sm ${config.text}`}>
            {status.message || 'Some features may be unavailable. We are monitoring the situation.'}
          </p>
          <a 
            href="https://status.planetscale.com" 
            target="_blank"
            className={`text-sm underline ${config.text}`}
          >
            View official status updates →
          </a>
        </div>
      </div>
    </div>
  );
}

FAQ: PlanetScale Status and Outages

How do I check if PlanetScale is down right now?

Visit status.planetscale.com for official PlanetScale platform status updates, or use API Status Check for real-time monitoring with automated alerts. You can also test database connectivity directly: try connecting to your PlanetScale database using the MySQL CLI or your application's database client.

What is the PlanetScale status page URL?

The official PlanetScale status page is status.planetscale.com. It provides real-time updates on all PlanetScale platform components including Database Connections, Control Plane API, Deploy Requests, Branching, Console UI, and Vitess Query Engine.

How often does PlanetScale go down?

PlanetScale maintains strong uptime (typically 99.95%+), but like any cloud database platform, occasional outages occur. Major platform-wide incidents affecting all users are rare (a few times per year), while minor degraded performance events or regional connectivity issues are more common. Check status.planetscale.com for historical incident data and uptime metrics specific to your database region.

How do I get notified when PlanetScale has an outage?

Subscribe to PlanetScale outage notifications via:

  • Email/SMS/Slack alerts from status.planetscale.com (click "Subscribe to Updates" button)
  • Automated alerts from API Status Check with instant notifications
  • PlanetScale Discord community announcements
  • Twitter notifications from @PlanetScale official account
  • Webhook integrations for PagerDuty, Opsgenie, or custom incident response systems
  • PlanetScale CLI status commands for programmatic monitoring

What should I do if my PlanetScale database connection is failing but the status page shows operational?

If PlanetScale shows operational but your connections fail, the issue is likely configuration-specific:

  1. Verify connection string - Check host, username, password, database name in .env or config file
  2. Test SSL/TLS settings - PlanetScale requires SSL connections; verify ssl: { rejectUnauthorized: true } configured
  3. Check IP allowlist - Ensure your application server IPs are whitelisted in PlanetScale database settings
  4. Review connection pool - Check max connections not exceeded; PlanetScale has per-plan limits
  5. Test from different location - Rule out network/firewall blocking MySQL port 3306
  6. Check database sleep state - Databases on free tier (discontinued 2024) could sleep; paid plans don't
  7. Review PlanetScale console logs - Check for authentication errors or quota violations
  8. Verify branch/database exists - Confirm you're connecting to correct branch and database name

Can I get a refund or service credit for PlanetScale downtime?

PlanetScale's Service Level Agreement (SLA) varies by plan tier. Enterprise and Scaler Pro plans typically include uptime guarantees with credits for SLA breaches (usually 99.95% or 99.99% uptime commitments). For service credit requests:

  • Document downtime duration, affected databases, business impact
  • Submit request through PlanetScale dashboard support ticket
  • Reference specific incident from status.planetscale.com
  • Include error logs and monitoring screenshots
  • Enterprise customers: contact dedicated account manager

Scaler and Hobby plans may have different SLA terms. Review your PlanetScale contract for specific credit eligibility.

How long do PlanetScale outages typically last?

Most PlanetScale incidents resolve within 30 minutes to 2 hours. Minor degraded performance issues (elevated latency, intermittent connection failures) often last 15-45 minutes, while major infrastructure outages affecting core database connectivity can occasionally extend to 1-3 hours. PlanetScale's engineering team prioritizes rapid incident response with progressive updates. Historical incident data with resolution times is available on status.planetscale.com in the incident timeline.

Is there a PlanetScale status API I can use programmatically?

Yes! Use API Status Check's PlanetScale endpoint (https://apistatuscheck.com/api/planetscale) for programmatic access to PlanetScale platform status. This JSON API allows you to:

  • Integrate PlanetScale status into dashboards and monitoring tools
  • Build health check endpoints that verify both PlanetScale platform status and actual database connectivity
  • Automate incident response workflows (failover, customer notifications, on-call alerts)
  • Track uptime metrics and historical outage patterns
  • Correlate PlanetScale status with your application error rates

How does PlanetScale compare to other databases for reliability?

PlanetScale competes with other serverless and cloud database platforms like Neon (serverless Postgres), Supabase (open-source Firebase alternative with Postgres), and Railway (simple deployment with multiple database options). Each platform has different uptime characteristics:

  • PlanetScale - Vitess-powered MySQL with branching; removed free tier in 2024
  • Neon - Serverless Postgres with auto-scaling; strong free tier
  • Supabase - Open-source, Postgres-based with real-time subscriptions
  • Railway - Simple deployment platform supporting MySQL, Postgres, Redis

For deployment infrastructure, pair your database choice with reliable platforms like Vercel, Cloudflare, or AWS. Monitor all critical dependencies to detect correlated infrastructure issues.

What happened to PlanetScale's free tier?

In April 2024, PlanetScale discontinued their free "Hobby" tier, requiring all users to migrate to paid Scaler plans (starting at $29/month) or migrate to alternative databases. This decision triggered significant community backlash and migration to competitors like Neon, Supabase, and self-hosted MySQL. The free tier removal announcement was widely discussed on Hacker News and developer communities. Existing free tier databases were given a sunset deadline to upgrade or export data.

Stay Ahead of PlanetScale Outages

Don't let PlanetScale downtime catch you off guard. Subscribe to API Status Check for:

  • ⚡ Instant alerts when PlanetScale platform status changes
  • 📊 Uptime tracking with historical outage data and incident patterns
  • 🔗 API access for programmatic status checks and dashboard integrations
  • 📱 Multi-channel notifications via email, Slack, Discord, webhook, or SMS
  • 🌍 Comprehensive monitoring of PlanetScale alongside 100+ other critical services including Neon, Supabase, Railway, Vercel, AWS, Stripe, and Cloudflare

Monitor PlanetScale status in real-time and respond to database incidents before they impact your users and revenue.

Get Started with PlanetScale Monitoring →

Last Updated: February 5, 2026
Related Guides: Neon Status | Supabase Status | Railway Status | AWS Status | Vercel Status | Cloudflare Status | Stripe Status

Monitor Your APIs

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

View API Status →