Where can I monitor API status in real-time?

API Status Check (apistatuscheck.com) provides real-time monitoring for 100+ APIs with uptime tracking and alerts. You can view dashboards, subscribe to feeds, and set up notifications in minutes.

Is Runway Down? How to Check Runway ML Status in Real-Time

Q: Is Runway Down? How to Check Runway ML Status in Real-Time?

This post explains Is Runway Down? How to Check Runway ML Status in Real-Time with clear steps and practical examples. Use the guidance to apply the recommendations in your own API workflows.

Quick Answer: To check if Runway is down, visit apistatuscheck.com/api/runway for real-time monitoring, or check Runway's official social media channels for updates. Common signs include video generation queue delays, Gen-2/Gen-3 model unavailability, credit system errors, export failures, and API rate limiting issues.

When your AI video generation tool suddenly stops working, creative workflows grind to a halt. Runway ML processes hundreds of thousands of AI video generations daily for filmmakers, content creators, and marketing teams worldwide, making any downtime a critical productivity blocker. Whether you're experiencing stalled video generation queues, Gen-3 Alpha model errors, or API integration failures, knowing how to quickly verify Runway's status can save valuable time and help you choose alternative workflows when needed.

How to Check Runway Status in Real-Time

1. API Status Check (Fastest Method)

The quickest way to verify Runway's operational status is through apistatuscheck.com/api/runway. 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 video generation availability continuously
Tests Gen-2 and Gen-3 model accessibility

Unlike relying on sporadic social media updates, API Status Check performs active health checks against Runway's production infrastructure, giving you the most accurate real-time picture of service availability for both the web application and API.

2. Official Runway Social Media

Runway doesn't maintain a traditional status page, so their primary communication channels during outages are:

Twitter/X: @runwayml for official announcements
Discord: Runway's community Discord server for real-time updates and user reports
Support: support@runwayml.com for direct incident inquiries
Instagram: @runway_ml for general updates

Pro tip: Follow Runway on Twitter and enable notifications to receive immediate alerts when they announce service disruptions or maintenance windows.

3. Test Video Generation Directly

If you're experiencing issues, perform a simple test generation:

Visit app.runwayml.com
Select Gen-2 or Gen-3 Alpha model
Create a simple text-to-video with a basic prompt like "A sunrise over mountains"
Observe queue position, processing time, and generation success

Look for:

Generation stuck in queue for >10 minutes
"Something went wrong" error messages
Model selection grayed out or unavailable
Credit deduction without video output
Export/download buttons unresponsive

4. Check API Endpoints for Developers

For developers integrating Runway's API, make a test request to confirm connectivity:

curl https://api.runwayml.com/v1/generation \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gen3a_turbo",
    "prompt": "A test video generation",
    "duration": 5
  }'

Watch for HTTP response codes outside the 2xx range, timeout errors, or rate limit responses when you haven't exceeded your quota. Common API endpoints to test:

/v1/generation - Video generation
/v1/generation/{id} - Generation status
/v1/models - Available models
/v1/account - Account and credits

5. Community Reports and Social Proof

Check communities where Runway users gather:

Reddit r/RunwayML
Twitter/X search for "Runway down" or "Runway ML not working"
Discord community channels
Hacker News discussions
DownDetector user reports (though less reliable for newer AI services)

Seeing multiple recent reports from different users across different regions confirms a broader outage versus an isolated issue or local connectivity problem.

Common Runway Issues and How to Identify Them

Video Generation Queue Delays

Normal vs. degraded performance:

Normal: Gen-2 processing 15-45 seconds per 4-second clip, Gen-3 Alpha 30-90 seconds per 5-10 second clip
Degraded: Queue position not moving for 5-10 minutes, estimated wait times exceeding 30 minutes
Severe outage: Generation stuck at "Starting..." or "Processing frame 0%" indefinitely, no progress after 20+ minutes

What causes queue delays:

GPU cluster capacity exhaustion during peak hours
Model server overload (especially for new Gen-3 releases)
Backend pipeline bottlenecks (prompt processing, frame generation, encoding)
Storage infrastructure strain affecting input/output operations

How to identify it's a system-wide issue:

Multiple generations across different accounts stuck
Queue estimates increasing dramatically
Generation failure rate spikes on simple, previously working prompts
Credit refunds appearing without successful video output

Gen-2/Gen-3 Model Availability

Symptoms of model infrastructure problems:

Gen-3 Alpha specific issues:

Model selection button grayed out or showing "Unavailable"
Switching from Gen-2 to Gen-3 results in errors
Gen-3 prompts failing while Gen-2 continues working
"Model capacity exceeded" messages
Fallback to Gen-2 even when Gen-3 selected

Gen-2 specific issues:

Image-to-video failing while text-to-video works
Motion brush features unavailable
Director mode controls unresponsive
Camera motion settings not applying to generation

What it means: Runway uses separate GPU clusters and model serving infrastructure for Gen-2 and Gen-3. During partial outages, one model may remain available while the other experiences issues. This is particularly common after major Gen-3 updates when demand spikes.

Credit and Subscription Issues

Common credit system problems during outages:

{
  "error": {
    "message": "Unable to verify credit balance",
    "type": "credit_system_error",
    "code": 500
  }
}

Signs of payment/billing infrastructure issues:

Credit balance showing as 0 when you have credits remaining
Video generations not deducting credits correctly
Subscription upgrade/renewal failing
Credit purchase transactions timing out
Duplicate credit charges without corresponding credit additions
API calls returning "insufficient credits" errors incorrectly

Impact on workflow:

Unable to start new generations despite valid subscription
Cannot purchase additional credits
Billing page loading errors
Subscription status showing incorrectly (expired when active)

Pro/Unlimited subscriber-specific issues:

Unlimited generations throttling unexpectedly
Pro features (upscaling, extend video, motion brush) unavailable
Workspace collaboration features broken

Export and Download Failures

Symptoms of video delivery pipeline issues:

During generation:

Video completes processing but "Download" button never appears
Export stuck at "Preparing download..." indefinitely
Download link generates but results in 404 error
Downloaded file is 0 bytes or corrupted

After generation:

Previously generated videos no longer accessible
Gallery loading errors or showing blank thumbnails
Shared video links returning errors
Inability to re-export or download past generations

What causes export failures:

Storage backend (S3/CDN) connectivity issues
Video encoding pipeline failures
CDN cache invalidation problems
Database sync issues between generation metadata and stored video files

How to verify it's a Runway issue:

# Test direct video URL access
curl -I https://storage.googleapis.com/runway-videos/[video-id].mp4

# Expected: 200 OK with content-type: video/mp4
# During outage: 403, 404, or timeout

API Rate Limiting and Integration Errors

For developers building on Runway's API:

Common API error responses during outages:

{
  "error": {
    "message": "Service temporarily unavailable",
    "type": "api_error",
    "code": 503,
    "retry_after": 120
  }
}

Unusual rate limiting patterns:

429 Too Many Requests on first API call of the day
Rate limits far below documented thresholds
Rate limit headers missing or showing incorrect values
Persistent 429s even after backing off exponentially

Gateway and infrastructure errors:

500 Internal Server Error - Backend processing failure
502 Bad Gateway - Load balancer cannot reach generation servers
503 Service Unavailable - Runway temporarily overloaded or deploying updates
504 Gateway Timeout - Generation request processing exceeded timeout threshold

WebSocket connection issues (for real-time generation updates):

WebSocket handshake failures
Connection drops mid-generation
No progress updates despite backend processing
Missing generation completion events

Image-to-Video and Motion Brush Failures

Symptoms specific to advanced features:

Image-to-video issues:

Image upload successful but generation fails to start
"Invalid image format" errors on supported formats (PNG, JPG, WebP)
First frame not matching uploaded image
Motion not applied correctly to image content

Motion brush problems:

Brush strokes not applying to video canvas
Motion vectors not affecting generation
Brush UI laggy or unresponsive
Saved motion paths not loading

Camera controls (Gen-2 Director Mode):

Pan, tilt, zoom controls not affecting output
Camera motion prompts ignored
Director mode reverting to standard generation

The Real Impact When Runway Goes Down

Content Creation Workflows Blocked

Runway has become mission-critical infrastructure for modern video creation:

Video creators and YouTubers:

B-roll generation for videos halted
Thumbnail and preview creation delayed
Sponsorship deliverables stuck in production
Content upload schedules at risk

Marketing teams:

Social media video campaigns delayed
Product demo videos stalled
Ad creative production blocked
Campaign launch deadlines threatened

Film and TV production:

Pre-visualization workflows interrupted
Concept art animatics delayed
VFX pre-production stalled
Client presentation materials incomplete

Productivity impact: For teams that have integrated Runway into production pipelines, downtime forces expensive alternatives—hiring motion graphics artists, using stock footage, or delaying entire projects. What takes 2 minutes with Runway might require 2 hours of manual work or external vendor coordination.

Revenue Loss for Content Businesses

For businesses monetizing video content, Runway downtime has direct financial impact:

YouTube creators:

Missed optimal posting windows for trending topics
Algorithm penalty for inconsistent posting schedule
Sponsorship deliverable delays risking contract penalties
Ad revenue loss from delayed uploads

Agencies and freelancers:

Client deliverables delayed, risking project penalties
Cannot bid on time-sensitive projects
Productivity loss billing hourly clients
Reputation damage from missed deadlines

Example calculation: A mid-tier YouTube creator producing 3 videos/week with 1M views averaging $3 CPM earns ~$3,000/week from AdSense. Missing one week of uploads due to Runway dependence = $3,000+ direct revenue loss, plus algorithm ranking impact on future videos.

Marketing Campaign Failures

Time-sensitive marketing campaigns face catastrophic risk:

Product launches:

Launch videos incomplete on announcement day
Social media teasers can't be produced
Demo videos unavailable for press
Influencer partnership content delayed

Seasonal campaigns:

Holiday creative production blocked
Limited-time offer videos delayed
Event promotion materials incomplete
Competitive timing advantage lost

Real scenario: A Black Friday campaign requires 50 product video variants generated through Runway. A 6-hour outage during final production day risks missing the campaign window entirely, representing weeks of planning and potentially hundreds of thousands in lost revenue.

Educational and Research Disruption

Academic use cases:

Film school assignments requiring AI video integration
Research projects studying generative AI capabilities
Educational content creation for online courses
Conference presentations and paper submissions

Corporate training:

Training video production delayed
Onboarding materials incomplete
Safety demonstration videos stalled
Product training content blocked

API-Dependent Applications and Services

Businesses building on Runway's API face cascading failures:

Example integrations:

Video editing SaaS products offering AI generation features
Social media management tools with built-in video creation
Marketing automation platforms with video ad generation
E-commerce platforms with product video automation

Impact chain:

Runway API becomes unavailable
Integrated application features break for all users
Support tickets spike
User churn increases
Revenue and reputation damage

Example: An e-commerce platform automatically generates product demo videos using Runway API. During extended outages, thousands of merchants cannot publish new product videos, leading to support escalations and potential platform abandonment.

Subscription Value Erosion

For Standard ($12/mo) and Pro ($28/mo) and Unlimited ($76/mo) subscribers:

During outages, paying subscribers experience:

Paying for credits they cannot use
Subscription period burning during downtime
Cannot justify cost vs. alternative tools
Consideration of subscription cancellation
Loss of competitive advantage vs. free tier users (everyone equally blocked)

Even brief but frequent outages erode the perceived value of paid plans. If users experience 3-4 significant disruptions per month, they may downgrade or switch to competitors like Stability AI or Replicate.

Incident Response Playbook: What to Do When Runway Goes Down

1. Verify It's Actually an Outage (Not Local Issues)

Before assuming Runway is down system-wide:

Quick diagnostic tests:

# Test your internet connectivity
ping google.com
ping runwayml.com

# Test DNS resolution
nslookup app.runwayml.com
dig app.runwayml.com

# Test HTTPS connectivity
curl -I https://app.runwayml.com
curl -I https://api.runwayml.com

# Check if it's regional
curl -I https://app.runwayml.com --resolve app.runwayml.com:443:1.2.3.4

Browser-specific checks:

Clear browser cache and cookies
Try incognito/private mode
Test in a different browser
Disable VPN if active
Check browser console for JavaScript errors (F12 → Console)

Account-specific checks:

Try logging out and back in
Verify your subscription status
Check credit balance
Review payment method validity

If other AI services work but only Runway is affected, it's likely a Runway infrastructure issue.

2. Switch to Alternative AI Video Generation Tools

Immediate alternatives for video generation:

For Gen-2/Gen-3 style text-to-video:

Pika Labs - Text-to-video and image-to-video with motion controls
Stability AI Video - Stable Video Diffusion for image-to-video
Leonardo.ai Motion - Image-to-video animation
Genmo - AI video generation with camera controls
Kaiber - Music video and transform style video generation

For API developers:

Replicate - Hosts Stable Video Diffusion and other video models
Stability AI API - Stable Video Diffusion API access
FAL.ai - Fast inference for various video generation models
Hugging Face Inference - Access to open-source video models

For image generation (as alternative workflow):

Midjourney - Generate still frames, animate separately
DALL-E 3 - High-quality image generation
Stable Diffusion - Open-source image generation

Workflow adaptation: When Runway is down, generate key frames with image AI tools, then use alternative video tools or traditional editing software (After Effects, Premiere Pro) for motion and transitions.

3. Implement Robust Retry Logic for API Users

For applications built on Runway API, implement resilient error handling:

async function runwayGenerationWithRetry(params, maxRetries = 5) {
  const backoffDelays = [1000, 2000, 5000, 10000, 30000]; // Progressive backoff
  
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch('https://api.runwayml.com/v1/generation', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${RUNWAY_API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          model: params.model || 'gen3a_turbo',
          prompt: params.prompt,
          duration: params.duration || 5,
          aspect_ratio: params.aspectRatio || '16:9'
        }),
        timeout: 60000 // 60 second timeout
      });

      // Success cases
      if (response.ok) {
        const data = await response.json();
        return { success: true, data };
      }

      // Rate limiting - use Retry-After header
      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After');
        const delay = retryAfter ? parseInt(retryAfter) * 1000 : backoffDelays[attempt];
        
        console.warn(`Rate limited. Retrying after ${delay}ms...`);
        await sleep(delay);
        continue;
      }

      // Server errors - retry with backoff
      if (response.status >= 500) {
        if (attempt < maxRetries - 1) {
          console.warn(`Server error ${response.status}. Retry ${attempt + 1}/${maxRetries}`);
          await sleep(backoffDelays[attempt]);
          continue;
        }
        throw new Error(`Runway API server error: ${response.status}`);
      }

      // Client errors - don't retry
      if (response.status >= 400 && response.status < 500) {
        const errorData = await response.json();
        throw new Error(`Runway API client error: ${errorData.error?.message || response.status}`);
      }

    } catch (error) {
      // Network errors, timeouts
      if (attempt < maxRetries - 1) {
        console.warn(`Network error: ${error.message}. Retry ${attempt + 1}/${maxRetries}`);
        await sleep(backoffDelays[attempt]);
        continue;
      }
      
      throw new Error(`Runway API failed after ${maxRetries} attempts: ${error.message}`);
    }
  }
  
  throw new Error('Runway API: Maximum retries exceeded');
}

// Poll for generation completion with exponential backoff
async function pollGenerationStatus(generationId, maxPolls = 60) {
  const pollIntervals = [2000, 3000, 5000]; // Start fast, slow down
  
  for (let poll = 0; poll < maxPolls; poll++) {
    try {
      const response = await fetch(`https://api.runwayml.com/v1/generation/${generationId}`, {
        headers: { 'Authorization': `Bearer ${RUNWAY_API_KEY}` }
      });

      if (!response.ok) {
        throw new Error(`Status check failed: ${response.status}`);
      }

      const data = await response.json();
      
      // Generation complete
      if (data.status === 'succeeded') {
        return { success: true, video_url: data.output.video_url };
      }
      
      // Generation failed
      if (data.status === 'failed') {
        throw new Error(`Generation failed: ${data.error?.message}`);
      }
      
      // Still processing - wait and poll again
      const delay = pollIntervals[Math.min(poll, pollIntervals.length - 1)];
      await sleep(delay);
      
    } catch (error) {
      if (poll < maxPolls - 1) {
        await sleep(5000);
        continue;
      }
      throw error;
    }
  }
  
  throw new Error('Generation timeout: Status polling exceeded maximum attempts');
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

4. Queue Requests for Later Processing

When Runway experiences extended downtime:

// Queue system with persistent storage
const { Queue } = require('bull'); // Or any job queue library
const runwayQueue = new Queue('runway-generations', {
  redis: { host: 'localhost', port: 6379 }
});

// Add generation to queue
async function queueOrGenerateVideo(params) {
  const isRunwayHealthy = await checkRunwayHealth();
  
  if (isRunwayHealthy) {
    // Process immediately
    return await runwayGenerationWithRetry(params);
  } else {
    // Queue for later processing
    const job = await runwayQueue.add('generate-video', params, {
      attempts: 3,
      backoff: {
        type: 'exponential',
        delay: 60000 // Start with 1 minute delay
      },
      removeOnComplete: true,
      removeOnFail: false
    });
    
    return {
      status: 'queued',
      jobId: job.id,
      message: 'Runway is currently experiencing issues. Your video generation has been queued and will process automatically when service is restored.',
      estimatedWait: 'Will begin processing within 30 minutes of service restoration'
    };
  }
}

// Process queued jobs when Runway recovers
runwayQueue.process('generate-video', async (job) => {
  const params = job.data;
  
  try {
    // Attempt generation
    const result = await runwayGenerationWithRetry(params);
    
    // Notify user of completion
    await notifyUser(params.userId, {
      type: 'video_ready',
      videoUrl: result.data.output.video_url,
      message: 'Your queued video generation is now complete!'
    });
    
    return result;
  } catch (error) {
    // If Runway still down, job will retry based on backoff settings
    throw error;
  }
});

// Health check function
async function checkRunwayHealth() {
  try {
    const response = await fetch('https://api.runwayml.com/v1/models', {
      headers: { 'Authorization': `Bearer ${RUNWAY_API_KEY}` },
      timeout: 5000
    });
    return response.ok;
  } catch {
    return false;
  }
}

5. Implement Multi-Provider Fallback System

For production applications, automatically fail over to alternative video generation services:

async function resilientVideoGeneration(params) {
  const providers = [
    {
      name: 'runway',
      fn: generateWithRunway,
      priority: 1,
      cost: 0.05, // per generation
      quality: 'highest'
    },
    {
      name: 'stability-video',
      fn: generateWithStabilityVideo,
      priority: 2,
      cost: 0.03,
      quality: 'high',
      requiresImage: true // Stability Video needs first frame image
    },
    {
      name: 'replicate',
      fn: generateWithReplicate,
      priority: 3,
      cost: 0.04,
      quality: 'medium'
    }
  ];

  let lastError;
  
  for (const provider of providers) {
    try {
      console.log(`Attempting video generation with ${provider.name}...`);
      
      // Adapt params for provider-specific requirements
      const adaptedParams = await adaptParamsForProvider(params, provider);
      
      const result = await provider.fn(adaptedParams);
      
      // Log fallback usage for monitoring
      if (provider.priority > 1) {
        await logFallback({
          primary: 'runway',
          fallback: provider.name,
          timestamp: Date.now(),
          reason: lastError?.message,
          cost_impact: provider.cost - providers[0].cost
        });
        
        // Notify engineering team if falling back frequently
        await checkFallbackRate('runway', provider.name);
      }
      
      return {
        ...result,
        provider: provider.name,
        fallback: provider.priority > 1
      };
      
    } catch (error) {
      console.warn(`${provider.name} failed: ${error.message}`);
      lastError = error;
      
      // Don't try next provider if this was a client error (bad params, auth, etc.)
      if (error.statusCode >= 400 && error.statusCode < 500) {
        throw error;
      }
      
      continue;
    }
  }
  
  // All providers failed
  throw new Error(`All video generation providers failed. Last error: ${lastError?.message}`);
}

// Provider-specific adapters
async function adaptParamsForProvider(params, provider) {
  if (provider.name === 'stability-video' && !params.image) {
    // Stability Video requires first frame - generate with Stable Diffusion
    const firstFrame = await generateFirstFrame(params.prompt);
    return { ...params, image: firstFrame };
  }
  
  if (provider.name === 'replicate') {
    // Replicate uses different model names
    return {
      ...params,
      model: 'stability-ai/stable-video-diffusion',
      version: 'latest'
    };
  }
  
  return params;
}

// Monitor fallback frequency
async function checkFallbackRate(primary, fallback) {
  const recentFallbacks = await getFallbackCount(primary, fallback, '1h');
  
  if (recentFallbacks > 10) {
    await alertEngineering({
      severity: 'warning',
      message: `High fallback rate from ${primary} to ${fallback}: ${recentFallbacks} in past hour`,
      action: 'Review primary provider status and consider scaling fallback infrastructure'
    });
  }
}

6. Communicate Proactively with Users

If you're running a service that depends on Runway:

Status page update:

⚠️ AI Video Generation - Degraded Performance

We're currently experiencing issues with AI video generation features due to 
problems with our video generation infrastructure provider (Runway ML).

Current status: Degraded - Increased processing times and queue delays
Impact: Video generations taking 3-5x longer than normal
Workaround: Requests are being queued and will process automatically when service improves
Alternative: Use image generation features for static content

Estimated resolution: Monitoring ongoing outage with upstream provider
Last updated: 3:42 PM PST

You can monitor Runway's status independently at: https://apistatuscheck.com/api/runway

In-app notification with graceful degradation:

if (runwayStatus === 'down' || runwayStatus === 'degraded') {
  showBanner({
    type: 'warning',
    icon: '⚠️',
    message: runwayStatus === 'down' 
      ? 'AI video generation is temporarily unavailable. Your requests will be queued and processed automatically when service is restored.'
      : 'AI video generation is running slower than normal. Estimated wait time: 5-10 minutes.',
    actions: [
      {
        label: 'Use alternative tool',
        link: '/tools/image-generation',
        style: 'secondary'
      },
      {
        label: 'View status',
        link: 'https://apistatuscheck.com/api/runway',
        external: true,
        style: 'link'
      }
    ],
    dismissible: true
  });
  
  // Update UI to show queued state
  videoGenerationButton.text = 'Generate (Queued)';
  videoGenerationButton.subtitle = 'Will process automatically';
}

Email notification for queued jobs:

Subject: Your AI Video Generation is Complete! 🎬

Hi {{user.name}},

Great news! Your video generation request that was queued during a temporary 
service disruption is now complete and ready to download.

Video: "{{video.prompt}}"
Duration: {{video.duration}}s
Model: {{video.model}}

[Download Video] [View in Dashboard]

Thanks for your patience during the service disruption. We've implemented 
additional monitoring and fallback systems to minimize future interruptions.

Happy creating!
The {{app.name}} Team

7. Monitor Proactively and Set Up Alerts

Personal monitoring for creators:

# Cron job to check Runway every 10 minutes
*/10 * * * * /home/user/scripts/check-runway.sh

# check-runway.sh
#!/bin/bash
RUNWAY_STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://app.runwayml.com)

if [ "$RUNWAY_STATUS" != "200" ]; then
  echo "Runway appears down (HTTP $RUNWAY_STATUS)" | \
    mail -s "⚠️ Runway Status Alert" your@email.com
fi

# Also check API if you're a developer
API_STATUS=$(curl -s -H "Authorization: Bearer $RUNWAY_API_KEY" \
  https://api.runwayml.com/v1/models -o /dev/null -w "%{http_code}")

if [ "$API_STATUS" != "200" ]; then
  echo "Runway API appears down (HTTP $API_STATUS)" | \
    mail -s "⚠️ Runway API Alert" your@email.com
fi

Production monitoring setup:

// Comprehensive health check
async function runwayHealthCheck() {
  const checks = {
    webApp: false,
    api: false,
    gen2: false,
    gen3: false,
    imageUpload: false,
    export: false
  };
  
  try {
    // Check web app availability
    const webResponse = await fetch('https://app.runwayml.com', { timeout: 5000 });
    checks.webApp = webResponse.ok;
    
    // Check API accessibility
    const apiResponse = await fetch('https://api.runwayml.com/v1/models', {
      headers: { 'Authorization': `Bearer ${RUNWAY_API_KEY}` },
      timeout: 5000
    });
    checks.api = apiResponse.ok;
    
    // Check Gen-2 generation (lightweight test)
    const gen2Test = await testGeneration('gen2', 2); // 2 second video
    checks.gen2 = gen2Test.success;
    
    // Check Gen-3 generation
    const gen3Test = await testGeneration('gen3a_turbo', 2);
    checks.gen3 = gen3Test.success;
    
  } catch (error) {
    console.error('Runway health check error:', error);
  }
  
  // Calculate overall health score
  const healthyCount = Object.values(checks).filter(Boolean).length;
  const totalChecks = Object.keys(checks).length;
  const healthScore = (healthyCount / totalChecks) * 100;
  
  // Emit metrics
  await recordMetrics('runway.health', {
    score: healthScore,
    checks,
    timestamp: Date.now()
  });
  
  // Alert on degradation
  if (healthScore < 80) {
    await alert({
      severity: healthScore < 50 ? 'critical' : 'warning',
      service: 'runway',
      message: `Runway health degraded to ${healthScore}%`,
      checks,
      runbook: 'https://docs.yourapp.com/runbooks/runway-outage'
    });
  }
  
  return { healthScore, checks };
}

// Run health checks every 2 minutes
setInterval(runwayHealthCheck, 120000);

Alert configuration recommendations:

Warning threshold: >10% error rate over 5 minutes, or response time >30s
Critical threshold: >50% error rate over 3 minutes, or complete unavailability >5 minutes
Page engineering: Critical alerts during business hours, warnings for tracking
Escalation: If unresolved after 30 minutes critical, escalate to on-call lead

Use API Status Check for managed monitoring:

Set up Runway monitoring
Configure alerts via email, Slack, Discord, or webhook
Receive notifications within 60 seconds of detected issues
Access historical uptime data and incident reports
Monitor entire AI stack: Stability AI, Replicate, OpenAI

8. Document Your Incident Response Process

Create a runbook for future Runway outages:

# Runway ML Outage Runbook

## Detection
- **Primary monitor:** https://apistatuscheck.com/api/runway
- **Alert threshold:** >15% error rate over 5min OR complete unavailability >3min
- **Alert channels:** #engineering-alerts (Slack), PagerDuty
- **On-call:** @video-platform-team

## Verification Steps
1. Check API Status Check dashboard for confirmation
2. Test direct generation via Runway web app
3. Make test API call with curl (see commands below)
4. Check [@runwayml Twitter](https://twitter.com/runwayml) for announcements
5. Verify not DNS/network issue on our infrastructure
6. Check error rate in application logs

## Verification Commands
```bash
# Test API health
curl https://api.runwayml.com/v1/models \
  -H "Authorization: Bearer $RUNWAY_API_KEY"

# Expected: 200 OK with model list
# Outage: 500/502/503 or timeout

# Test generation (uses credits!)
curl https://api.runwayml.com/v1/generation \
  -H "Authorization: Bearer $RUNWAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gen3a_turbo","prompt":"test","duration":2}'

Response Actions (in order)

Immediate (0-5 minutes)

Enable fallback provider (Stability Video or Replicate)
- Run: ./scripts/enable-video-fallback.sh stability
- Verify: Check /health/video-generation endpoint
Post status update to status page
Enable request queuing for non-critical generations
Notify customer success team via #customer-success Slack

Short-term (5-30 minutes)

Queue incoming video generation requests
Monitor fallback provider capacity and costs
Communicate to affected users (in-app banner, email for queued jobs)
Track error rate and failed request count
Document incident timeline in incident log

Recovery (when Runway service restored)

Verify service restoration via test generation
Gradually process queued requests (50/min to avoid overwhelming Runway)
Monitor for data consistency issues (credit deductions, video availability)
Disable fallback provider once stable for 15 minutes
Post all-clear to status page
Send completion notifications for queued jobs

Communication Templates

Status Page (Investigating)

⚠️ Investigating AI Video Generation Issues

We're investigating reports of failed video generations and increased 
processing times. Our team is actively monitoring the situation.

Status: Investigating
Started: {{incident.start_time}}
Next update: Within 15 minutes

Status Page (Identified)

⚠️ AI Video Generation - Degraded Performance

Our video generation provider (Runway ML) is experiencing service disruptions. 
We've enabled automatic fallback to alternative providers and are queuing 
requests for optimal processing.

Status: Degraded - Requests queued, will process automatically
Impact: 2-5x longer processing times
Workaround: Use image generation for static content needs
Estimated resolution: Monitoring upstream provider status

Status Page (Resolved)

✅ AI Video Generation - Resolved

Video generation services have been fully restored. Queued requests are now 
processing and should complete within 30 minutes.

Duration: {{incident.duration}}
Affected users: ~{{affected_count}}
Root cause: Upstream provider infrastructure issues

Contacts

Runway support: support@runwayml.com
Internal escalation: @video-platform-lead
Status updates: #platform-incidents
Customer comms: @customer-success-lead

Post-Incident

Write postmortem within 48 hours (template: /docs/postmortem-template.md)
Review fallback effectiveness and costs
Identify improvements to resilience and monitoring
Update runbook with lessons learned
Share learnings with engineering team

Related Documentation


Save this runbook where your team can easily access it during incidents.

## Frequently Asked Questions

### How often does Runway ML experience outages?

Runway has generally maintained strong uptime as they've scaled their infrastructure, though as a rapidly growing AI video generation service, they occasionally experience growing pains. Minor slowdowns or partial outages (affecting specific models or features) occur a few times per month, particularly after major model releases like Gen-3 Alpha. Complete service disruptions affecting all users are less frequent, typically 2-4 times per quarter. API users may experience rate limiting or model unavailability during peak demand periods even when the consumer web application works normally. Monitor real-time status at [apistatuscheck.com/api/runway](https://apistatuscheck.com/api/runway).

### What's the difference between Runway being slow vs. actually down?

**Slow (degraded performance):** Video generations eventually complete but take significantly longer—perhaps 5-10 minutes for a Gen-2 clip that normally takes 45 seconds, or queue positions advancing slowly but steadily. You may need to retry once or twice, but generations ultimately succeed. This indicates backend capacity strain, model server load, or processing pipeline bottlenecks.

**Actually down:** Generations consistently fail, time out after 15-20 minutes, or never leave "Starting..." status. Multiple retries across different prompts and models all fail. The web app may be unreachable, show error pages, or API calls return 500/502/503 errors. This indicates infrastructure failure, deployment issues, or upstream provider (cloud/GPU) outages. The key difference: slow degrades gracefully over time; down fails immediately or after timeout.

### Can I get a refund or credit if Runway is down?

Runway's Terms of Service don't guarantee specific uptime SLAs or provide automatic refunds for service disruptions. However, if you experience significant recurring outages that substantially impact your subscription value, you can contact support@runwayml.com to discuss your concerns. Some users report receiving pro-rated credits, additional generation credits, or subscription extensions for extended outages, particularly for Pro and Unlimited subscribers. Document the specific impact (dates, duration, projects affected) when reaching out to support—this strengthens your case for compensation.

### Why does Runway's API go down more often than the web app?

API infrastructure faces different challenges than the consumer web interface:

- **Load patterns:** API users can generate hundreds of concurrent requests; web users typically generate sequentially
- **Model allocation:** API and web app may use separate GPU pools with independent availability
- **Caching limitations:** Web app benefits from generation caching; API calls often require fresh generations
- **Rate limiting complexity:** API requires sophisticated rate limiting across thousands of keys vs. user-based web throttling
- **Integration dependencies:** API issues can stem from authentication services, webhook systems, or other infrastructure not used by web app

Monitor them independently: [Runway API Status](https://apistatuscheck.com/api/runway). If you're building production features on the API, always implement fallback logic to alternative video generation services like [Stability AI](https://apistatuscheck.com/api/stability-ai) or [Replicate](https://apistatuscheck.com/api/replicate).

### Should I build critical production features on Runway's API?

Runway provides powerful AI video generation capabilities, but consider these factors when planning production integrations:

**Good use cases:**
- Content creation tools where video is enhanced feature, not core
- Marketing automation where video generation can queue during busy periods
- Creative applications with multiple generation options
- Internal tools and productivity enhancements
- Applications with human review before publication

**Risky for:**
- Real-time video generation for live events or streaming
- Mission-critical customer-facing features without fallback providers
- Applications requiring guaranteed <60s generation times
- High-volume production workloads without significant rate limit headroom
- Time-sensitive automated workflows (scheduled social posts, campaign launches)

**Best practices for production use:**
1. Implement automatic fallback to alternative providers ([Stability Video](https://apistatuscheck.com/api/stability-ai), [Replicate](https://apistatuscheck.com/api/replicate))
2. Use queue systems for non-time-sensitive generations
3. Monitor with [API Status Check](https://apistatuscheck.com/api/runway) and internal health checks
4. Cache and reuse generations when possible
5. Set clear user expectations about generation times
6. Have manual workflow alternatives documented

### How do I know if it's Runway or my API key/account?

**Test systematically to isolate the issue:**

**1. Verify API key validity:**
```bash
# This should return 401 Unauthorized if key is invalid
curl https://api.runwayml.com/v1/account \
  -H "Authorization: Bearer YOUR_API_KEY"

# Expected: 200 OK with account info
# Invalid key: 401 Unauthorized
# Runway outage: 500/502/503 or timeout

2. Check credit balance:

Log into app.runwayml.com
View account credits
Verify subscription status
Check payment method validity

3. Test with web app:

Log into your account on app.runwayml.com
Attempt a simple Gen-2 generation
If web app works but API fails → API-specific issue
If both fail → account or global outage issue

4. Check API Status Check:

Visit apistatuscheck.com/api/runway
If showing operational but you're failing → likely account/key issue
If showing degraded/down → Runway infrastructure issue

5. Test from different environment:

Try API call from different network/machine
Use curl directly (eliminates application bugs)
Test with a different API key if available

6. Review rate limits:

# Check rate limit headers in API response
curl -i https://api.runwayml.com/v1/models \
  -H "Authorization: Bearer YOUR_API_KEY"

# Look for headers:
# X-RateLimit-Limit: 100
# X-RateLimit-Remaining: 45
# X-RateLimit-Reset: 1609459200

If curl works but your application doesn't, it's an integration issue. If curl fails and API Status Check shows problems, it's a Runway outage. If curl fails but API Status Check shows healthy, it's likely your account/key.

What happens to my credits during an outage?

Runway's credit system behavior during outages:

Typical behavior:

Failed generations: Credits typically auto-refunded within minutes to hours
Queued generations: Credits not deducted until generation begins processing
Partially completed: If generation fails mid-process, credits usually refunded
Successful but unable to export: Credits deducted (generation completed), export issues separate

Monitor your credit balance:

Check account page on app.runwayml.com
Review transaction history for refunds
API response includes credit deduction confirmation

If credits aren't refunded properly:

Wait 24 hours (refunds sometimes process in batches)
Document failed generations (screenshots, error messages, timestamps)
Contact support@runwayml.com with evidence
Reference specific generation IDs from API responses if available

For Pro/Unlimited subscribers, credit refund issues are less relevant since you have unlimited generations, but service availability itself becomes the primary concern.

Are there status page alternatives besides API Status Check?

Unlike major platforms, Runway doesn't maintain an official status page (no status.runwayml.com equivalent). Your best monitoring options:

Official channels:

@runwayml on Twitter/X - Primary announcement channel
Runway Discord server - Community reports and occasional official updates
support@runwayml.com - Direct support for incident inquiries
Instagram @runway_ml - General updates

Third-party monitoring:

API Status Check - Automated real-time monitoring with historical data
DownDetector user reports - Crowdsourced, less reliable for newer services
Reddit r/RunwayML - Community discussions and outage reports
Twitter search for "Runway down" or "Runway ML not working"

DIY monitoring:

# Set up your own monitoring with cron
*/5 * * * * /home/user/scripts/check-runway.sh

# check-runway.sh
#!/bin/bash
STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $RUNWAY_API_KEY" \
  https://api.runwayml.com/v1/models)

if [ "$STATUS" != "200" ]; then
  echo "Runway API returned $STATUS" | \
    mail -s "Runway Alert" you@email.com
fi

Professional monitoring tools:

Pingdom synthetic monitoring
Datadog API checks
UptimeRobot endpoint monitoring
Custom health checks in your application monitoring

For mission-critical production applications, use multiple monitoring sources: API Status Check for real-time alerts + Twitter for official announcements + your own internal health checks.

How does Runway downtime compare to other AI video tools?

AI video generation is still an emerging category with infrastructure challenges across all providers:

Runway ML:

Generally strong uptime for a rapidly evolving service
Occasional model-specific outages (Gen-3 separate from Gen-2)
API stability improving as they scale
Peak demand periods can cause slowdowns

Stability AI Video (Stable Video Diffusion):

More established API infrastructure through Stability AI
Limited to image-to-video (requires first frame)
Generally stable but with capacity constraints
Shorter video lengths than Runway

Pika Labs:

Consumer-focused, less API maturity
Frequent model updates can cause temporary disruption
Slower generation speeds during peak times

Replicate (hosting various models):

Replicate offers strong infrastructure reliability
Hosts multiple video models with independent availability
Better API uptime than model-specific services
Cold start delays when models aren't actively used

Recommendation for production: Don't rely on any single AI video provider. Implement fallback logic across multiple services. Monitor your entire stack with API Status Check multi-service monitoring to get alerts before your users notice issues.

Stay Ahead of Runway Outages

Don't let AI video generation disruptions halt your creative workflow or business operations. Subscribe to real-time Runway ML alerts and get notified instantly when issues are detected—before your video production pipeline breaks.

API Status Check monitors Runway ML 24/7 with:

60-second health checks for web app, API, and generation endpoints
Instant alerts via email, Slack, Discord, or webhook when issues detected
Model-specific monitoring tracking Gen-2 and Gen-3 availability separately
Historical uptime tracking and incident reports with duration and impact data
Multi-service monitoring for your entire AI creative stack:
- Stability AI - Image and video generation
- Replicate - AI model hosting and inference
- OpenAI - GPT models and DALL-E
- Midjourney - AI image generation
- Anthropic Claude - AI assistant and coding

Why API Status Check?

Active testing of actual endpoints, not just ping checks
Sub-minute detection of issues (60s poll frequency)
Historical data helps you understand reliability patterns before committing to paid plans
Multi-region monitoring detects regional outages others might miss
Comprehensive AI monitoring - track 50+ AI services from one dashboard

Start monitoring Runway ML now →

For developers: Integrate API Status Check into your incident response automation:

// Example: Check Runway status before attempting generation
const response = await fetch('https://apistatuscheck.com/api/runway/status');
const { status, uptime, responseTime } = await response.json();

if (status !== 'operational') {
  // Fall back to alternative provider
  return await generateWithFallbackProvider(params);
}

Production-Ready Monitoring

Building a business on AI video generation? Get enterprise-grade monitoring with:

Custom alert thresholds and escalation rules
Webhook integration for automated incident response
SLA tracking and uptime guarantees visibility
Team notifications via Slack, Discord, PagerDuty
API access to status data for your own dashboards

Explore API Status Check pricing →

Last updated: February 4, 2026. Runway ML status information is provided in real-time based on active monitoring. For official updates, follow @runwayml on Twitter/X or contact support@runwayml.com. This guide covers Gen-2, Gen-3 Alpha, Gen-3 Turbo, and Runway API.