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

Quick Answer: To check if AssemblyAI is down, visit apistatuscheck.com/api/assemblyai for real-time monitoring, or check the official status.assemblyai.com page. Common signs include transcription job failures, real-time streaming disconnects, speaker diarization errors, webhook delivery failures, and elevated API response times.

When your speech-to-text pipeline suddenly stops processing, every minute of downtime affects your users' experience and your business operations. AssemblyAI powers transcription and audio intelligence for thousands of applications—from podcast platforms and meeting software to call analytics and content moderation systems. Whether you're seeing failed transcription jobs, streaming disconnects, or webhook timeouts, quickly verifying AssemblyAI's status can help you distinguish between service issues and problems in your own infrastructure.

How to Check AssemblyAI Status in Real-Time

1. API Status Check (Fastest Method)

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

• Tests actual API endpoints every 60 seconds
• Monitors transcription submission and processing
• Tracks API response times and latency trends
• Shows historical uptime over 30/60/90 days
• Provides instant alerts when issues are detected
• Tests real-time streaming connectivity

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

2. Official AssemblyAI Status Page

AssemblyAI maintains status.assemblyai.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 (Transcription API, Real-Time API, LeMUR, Audio Intelligence features)

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

3. Test API Endpoints Directly

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

import assemblyai as aai

# Quick health check
aai.settings.api_key = "your-api-key"

try:
    # Test transcription submission (fast check)
    config = aai.TranscriptionConfig()
    transcriber = aai.Transcriber(config=config)
    
    # Use a short audio file for testing
    transcript = transcriber.transcribe("https://example.com/test-audio.mp3")
    
    if transcript.status == aai.TranscriptStatus.error:
        print("AssemblyAI returned an error:", transcript.error)
    else:
        print("AssemblyAI is operational")
        
except Exception as e:
    print(f"Cannot reach AssemblyAI: {e}")

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

4. Monitor Your Transcription Dashboard

Check the AssemblyAI Dashboard at www.assemblyai.com/app for:

• Recent transcription job statuses
• Processing queue lengths (unusually long queues indicate capacity issues)
• API usage graphs showing sudden drops
• Error rate spikes in your request history

5. Check Community Channels

During outages, developers often report issues before official status updates:

• AssemblyAI Discord community
• Twitter/X search for "@assemblyai down" or "assemblyai outage"
• Reddit r/MachineLearning or r/webdev discussions
• Stack Overflow recent questions about AssemblyAI errors

Common AssemblyAI Issues and How to Identify Them

Transcription Job Failures

Symptoms:

• Jobs stuck in queued status for extended periods (>5 minutes)
• Jobs immediately failing with error status
• 500 Internal Server Error responses when submitting transcriptions
• Timeout errors during job submission (no response within 30-60 seconds)

What it means: When AssemblyAI's transcription pipeline is degraded, you'll see abnormal failure patterns across multiple audio files. This differs from normal failures due to invalid audio formats or corrupted files—you'll see a pattern of failures across different files that previously worked.

Example error handling:

import assemblyai as aai
import time

aai.settings.api_key = "your-api-key"

def transcribe_with_retry(audio_url, max_retries=3):
    for attempt in range(max_retries):
        try:
            transcriber = aai.Transcriber()
            transcript = transcriber.transcribe(audio_url)
            
            # Check for service errors
            if transcript.status == aai.TranscriptStatus.error:
                error_msg = transcript.error
                if "internal server error" in error_msg.lower():
                    print(f"AssemblyAI service error (attempt {attempt + 1}): {error_msg}")
                    time.sleep(2 ** attempt)  # Exponential backoff
                    continue
                else:
                    # File-specific error, don't retry
                    raise ValueError(f"Transcription failed: {error_msg}")
            
            return transcript
            
        except Exception as e:
            print(f"Request failed (attempt {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    
    raise Exception("AssemblyAI appears to be experiencing issues")

Real-Time Streaming Disconnects

Indicators:

• WebSocket connections dropping immediately after establishment
• connection_closed events firing unexpectedly
• Audio chunks not being processed
• Transcript results stopping mid-stream
• Reconnection attempts failing repeatedly

Common error codes:

• 4000 - WebSocket protocol error
• 4001 - Authentication failed (may indicate API service issues)
• 4008 - Rate limit exceeded (unusual if within normal usage)
• 4029 - Insufficient credit (verify account status first)

Streaming health check:

import assemblyai as aai

def test_realtime_connection():
    aai.settings.api_key = "your-api-key"
    
    try:
        transcriber = aai.RealtimeTranscriber(
            sample_rate=16000,
            on_data=lambda transcript: print(transcript.text),
            on_error=lambda error: print(f"Error: {error}"),
        )
        
        transcriber.connect()
        
        # Send test audio chunk
        # If this fails immediately, AssemblyAI streaming may be down
        
        transcriber.close()
        print("Real-time API is operational")
        
    except Exception as e:
        print(f"Real-time API check failed: {e}")

Speaker Diarization Errors

Symptoms:

• Diarization feature returning errors when enabled
• Speaker labels missing from transcripts
• Significantly longer processing times for diarization jobs
• Inconsistent speaker detection across similar audio files

What to check:

config = aai.TranscriptionConfig(
    speaker_labels=True
)

transcriber = aai.Transcriber(config=config)
transcript = transcriber.transcribe(audio_url)

if transcript.status == aai.TranscriptStatus.completed:
    if not transcript.utterances or len(transcript.utterances) == 0:
        print("Warning: Diarization may be degraded (no speaker labels)")

Webhook Delivery Failures

AssemblyAI sends webhooks when transcription jobs complete. During outages:

• Webhooks not arriving at your endpoint
• Significant delays (minutes to hours instead of seconds)
• Missing or malformed webhook payloads
• Duplicate webhook deliveries

Webhook verification:

from flask import Flask, request
import hashlib
import hmac

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def assemblyai_webhook():
    # Verify webhook signature
    signature = request.headers.get('X-AssemblyAI-Signature')
    
    if not signature:
        print("Warning: Webhook missing signature (possible delivery issue)")
        return 'No signature', 400
    
    payload = request.get_data()
    webhook_secret = "your-webhook-secret"
    
    expected_signature = hmac.new(
        webhook_secret.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    
    if not hmac.compare_digest(signature, expected_signature):
        print("Warning: Invalid webhook signature")
        return 'Invalid signature', 401
    
    data = request.json
    transcript_id = data.get('transcript_id')
    status = data.get('status')
    
    print(f"Received webhook for {transcript_id}: {status}")
    
    return 'OK', 200

If your endpoint is confirmed working and you're not receiving webhooks for completed jobs, AssemblyAI's webhook system may be experiencing issues.

Rate Limiting and Throttling

Indicators:

• 429 Too Many Requests errors when within normal usage limits
• Concurrent request limits hit immediately
• Sudden drops in allowed requests per second
• "Rate limit exceeded" errors across multiple API keys

Rate limit check:

import requests

def check_rate_limits():
    headers = {
        "authorization": "your-api-key"
    }
    
    response = requests.get(
        "https://api.assemblyai.com/v2/transcript",
        headers=headers
    )
    
    # Check rate limit headers
    remaining = response.headers.get('X-RateLimit-Remaining')
    reset_time = response.headers.get('X-RateLimit-Reset')
    
    print(f"Remaining requests: {remaining}")
    print(f"Reset time: {reset_time}")
    
    if response.status_code == 429:
        print("Rate limited - check if this is expected based on your plan")

If you're being rate-limited well below your plan's normal limits, this may indicate AssemblyAI is throttling requests due to capacity issues.

The Real Impact When AssemblyAI Goes Down

Podcast and Media Production Halts

Immediate consequences:

• Podcast episodes cannot be transcribed for show notes
• Video subtitles and captions generation blocked
• Content indexing and search stopped
• Accessibility features unavailable

For a podcast network processing 100 episodes per day, a 4-hour outage means:

• 17+ episodes backlogged
• Manual transcription costs ($1-2 per minute of audio)
• Delayed content publication
• SEO impact from missing transcripts

Meeting and Call Analytics Disrupted

Real-time impacts:

• Live meeting transcription fails during critical calls
• Sales call analysis and coaching insights unavailable
• Customer support quality monitoring disabled
• Compliance recording requirements violated

Example: A sales team conducting 50 discovery calls per day loses valuable insights:

• No automated CRM note-taking
• Missing competitor mentions and objections
• Lost coaching opportunities
• Reduced sales intelligence

Content Moderation Gaps

Many platforms use AssemblyAI for audio content moderation:

• Inappropriate content detection delayed
• Compliance violations undetected
• Platform safety compromised
• Regulatory risk increased

Impact timeline:

• 0-15 minutes: Unmoderated content begins publishing
• 15-60 minutes: Volume of unreviewed content grows
• 1-4 hours: Significant moderation backlog
• 4+ hours: Manual moderation required or content publishing paused

Call Center and Voicemail Transcription Backlog

Operational disruptions:

• Voicemail-to-text services fail
• Call center analytics dashboard goes dark
• Customer sentiment analysis unavailable
• Quality assurance workflows blocked

For call centers processing 10,000+ calls daily:

• Support tickets pile up without automated triage
• Manager coaching sessions lack transcription data
• Compliance audits cannot proceed
• Customer experience metrics unavailable

Application User Experience Degradation

Applications with AssemblyAI integrated into user-facing features suffer immediate UX issues:

• Voice note transcription fails in messaging apps
• Video conferencing tools cannot provide live captions
• Accessibility features break for hearing-impaired users
• Voice command applications stop responding

User impact metrics:

• Increased support tickets (50-200% spike during outages)
• App store rating drops (every outage risks 1-star reviews)
• User churn acceleration
• Social media complaints trending

Revenue and Business Continuity Impact

Direct financial effects:

• SaaS platforms cannot onboard new customers (transcription in signup flow)
• Usage-based billing cannot track consumption
• Enterprise customers hit SLA breach penalties
• Refund requests spike post-outage

Estimated costs:

• Small startup (100 daily transcriptions): $500-2,000 lost productivity per outage
• Mid-size company (1,000+ daily): $5,000-20,000 in direct costs
• Enterprise (10,000+ daily): $50,000+ including SLA penalties and emergency manual processing

What to Do When AssemblyAI Goes Down

1. Implement Robust Error Handling and Retries

Exponential backoff for API requests:

import assemblyai as aai
import time
from typing import Optional

def transcribe_with_backoff(
    audio_url: str,
    max_retries: int = 5,
    initial_delay: float = 1.0
) -> Optional[aai.Transcript]:
    """
    Transcribe audio with exponential backoff retry logic
    """
    aai.settings.api_key = "your-api-key"
    
    for attempt in range(max_retries):
        try:
            config = aai.TranscriptionConfig(
                speech_model=aai.SpeechModel.best,
            )
            transcriber = aai.Transcriber(config=config)
            transcript = transcriber.transcribe(audio_url)
            
            # Handle different failure scenarios
            if transcript.status == aai.TranscriptStatus.error:
                error_msg = transcript.error.lower()
                
                # Retryable errors
                if any(x in error_msg for x in ['internal error', 'timeout', 'unavailable']):
                    delay = initial_delay * (2 ** attempt)
                    print(f"Retryable error (attempt {attempt + 1}/{max_retries}): {transcript.error}")
                    print(f"Waiting {delay}s before retry...")
                    time.sleep(delay)
                    continue
                else:
                    # Non-retryable error (bad audio, invalid format, etc.)
                    print(f"Non-retryable error: {transcript.error}")
                    return None
            
            # Success
            return transcript
            
        except requests.exceptions.Timeout:
            delay = initial_delay * (2 ** attempt)
            print(f"Request timeout (attempt {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                time.sleep(delay)
            else:
                print("Max retries exceeded - AssemblyAI may be experiencing an outage")
                return None
                
        except requests.exceptions.ConnectionError as e:
            print(f"Connection error: {e}")
            if attempt < max_retries - 1:
                time.sleep(initial_delay * (2 ** attempt))
            else:
                return None
    
    return None

2. Queue Jobs for Later Processing

When AssemblyAI is down, queue transcription jobs instead of failing immediately:

from redis import Redis
from rq import Queue
import json

# Setup Redis queue
redis_conn = Redis()
transcription_queue = Queue('transcriptions', connection=redis_conn)

def queue_transcription(audio_url: str, metadata: dict):
    """
    Queue transcription job when AssemblyAI is unavailable
    """
    job = transcription_queue.enqueue(
        'tasks.process_transcription',
        audio_url=audio_url,
        metadata=metadata,
        retry=True,
        job_timeout='1h'
    )
    
    print(f"Queued transcription job: {job.id}")
    return job.id

def process_transcription(audio_url: str, metadata: dict):
    """
    Worker function to process queued transcriptions
    """
    transcript = transcribe_with_backoff(audio_url)
    
    if transcript and transcript.status == aai.TranscriptStatus.completed:
        # Store results
        save_transcript(transcript, metadata)
        
        # Notify user
        notify_user(metadata['user_id'], 'Transcription completed', transcript.id)
    else:
        # Re-queue if still failing
        raise Exception("Transcription failed - will retry")

3. Implement Fallback Speech-to-Text Providers

Consider multi-provider strategies for mission-critical applications:

Primary: AssemblyAI (best accuracy for most use cases) Fallback options:

• Deepgram - excellent for real-time streaming
• OpenAI Whisper API - strong multilingual support
• Google Speech-to-Text - reliable enterprise option
• AWS Transcribe - good AWS ecosystem integration

Intelligent failover implementation:

import assemblyai as aai
from deepgram import Deepgram
import openai

class MultiProviderTranscriber:
    def __init__(self):
        self.assemblyai_key = "your-assemblyai-key"
        self.deepgram_key = "your-deepgram-key"
        self.openai_key = "your-openai-key"
        
    async def transcribe(self, audio_url: str, prefer_provider: str = "assemblyai"):
        """
        Transcribe with automatic failover
        """
        providers = [prefer_provider] + [p for p in ["assemblyai", "deepgram", "openai"] 
                                          if p != prefer_provider]
        
        for provider in providers:
            try:
                if provider == "assemblyai":
                    return await self._transcribe_assemblyai(audio_url)
                elif provider == "deepgram":
                    return await self._transcribe_deepgram(audio_url)
                elif provider == "openai":
                    return await self._transcribe_openai(audio_url)
            except Exception as e:
                print(f"{provider} failed: {e}, trying next provider...")
                continue
        
        raise Exception("All transcription providers failed")
    
    async def _transcribe_assemblyai(self, audio_url: str):
        aai.settings.api_key = self.assemblyai_key
        transcriber = aai.Transcriber()
        transcript = transcriber.transcribe(audio_url)
        
        if transcript.status == aai.TranscriptStatus.error:
            raise Exception(f"AssemblyAI error: {transcript.error}")
        
        return {
            'provider': 'assemblyai',
            'text': transcript.text,
            'confidence': transcript.confidence,
            'words': transcript.words
        }
    
    async def _transcribe_deepgram(self, audio_url: str):
        dg_client = Deepgram(self.deepgram_key)
        response = await dg_client.transcription.prerecorded(
            {'url': audio_url},
            {'punctuate': True, 'diarize': True}
        )
        
        return {
            'provider': 'deepgram',
            'text': response['results']['channels'][0]['alternatives'][0]['transcript']
        }
    
    async def _transcribe_openai(self, audio_url: str):
        # Download audio and transcribe with Whisper
        # (OpenAI requires file upload, not URL)
        openai.api_key = self.openai_key
        
        # Implementation details...
        pass

4. Poll for Job Status Instead of Relying Solely on Webhooks

Webhooks can fail during outages. Implement polling as backup:

import time
from typing import Optional

def wait_for_transcript(
    transcript_id: str,
    max_wait_seconds: int = 300,
    poll_interval: int = 5
) -> Optional[aai.Transcript]:
    """
    Poll for transcript completion instead of waiting for webhook
    """
    aai.settings.api_key = "your-api-key"
    transcriber = aai.Transcriber()
    
    start_time = time.time()
    
    while True:
        elapsed = time.time() - start_time
        
        if elapsed > max_wait_seconds:
            print(f"Timeout waiting for transcript {transcript_id}")
            return None
        
        try:
            transcript = transcriber.get_transcript(transcript_id)
            
            if transcript.status == aai.TranscriptStatus.completed:
                return transcript
            elif transcript.status == aai.TranscriptStatus.error:
                print(f"Transcription failed: {transcript.error}")
                return None
            else:
                # Still processing
                print(f"Status: {transcript.status}, waiting...")
                time.sleep(poll_interval)
                
        except Exception as e:
            print(f"Error checking transcript status: {e}")
            time.sleep(poll_interval)

5. Cache and Store Audio Files Reliably

Don't rely on AssemblyAI to store your audio long-term:

import boto3
from datetime import datetime, timedelta

s3_client = boto3.client('s3')

def upload_and_transcribe(audio_file_path: str, metadata: dict):
    """
    Upload audio to S3 first, then transcribe from S3
    """
    # Generate unique S3 key
    timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
    s3_key = f"audio/{metadata['user_id']}/{timestamp}-{metadata['filename']}"
    
    # Upload to S3
    s3_client.upload_file(
        audio_file_path,
        'your-audio-bucket',
        s3_key,
        ExtraArgs={'ContentType': 'audio/mpeg'}
    )
    
    # Generate presigned URL (valid for 7 days)
    audio_url = s3_client.generate_presigned_url(
        'get_object',
        Params={'Bucket': 'your-audio-bucket', 'Key': s3_key},
        ExpiresIn=604800
    )
    
    # Now transcribe from S3
    transcript = transcribe_with_backoff(audio_url)
    
    # Store transcript results alongside audio
    if transcript:
        s3_client.put_object(
            Bucket='your-audio-bucket',
            Key=f"{s3_key}.transcript.json",
            Body=json.dumps({
                'text': transcript.text,
                'words': [{'text': w.text, 'start': w.start, 'end': w.end} 
                         for w in transcript.words],
                'metadata': metadata
            })
        )
    
    return transcript

This ensures you can retry transcription even if AssemblyAI was down when you first attempted it.

6. Monitor and Alert Aggressively

Set up comprehensive monitoring before outages happen:

import requests
import time
from datetime import datetime

def health_check_assemblyai():
    """
    Periodic health check for AssemblyAI services
    """
    checks = {
        'api_reachable': False,
        'transcription_submission': False,
        'realtime_connection': False,
        'response_time_ms': None
    }
    
    # 1. Check API reachability
    try:
        start = time.time()
        response = requests.get(
            'https://api.assemblyai.com/v2/transcript',
            headers={'authorization': 'your-api-key'},
            timeout=10
        )
        checks['response_time_ms'] = (time.time() - start) * 1000
        checks['api_reachable'] = response.status_code in [200, 401]  # 401 = auth issue but API is up
    except Exception as e:
        print(f"API unreachable: {e}")
    
    # 2. Test transcription submission (use cached test audio)
    if checks['api_reachable']:
        try:
            aai.settings.api_key = "your-api-key"
            transcriber = aai.Transcriber()
            
            # Submit very short test audio
            transcript = transcriber.transcribe("https://your-cdn.com/test-audio-1sec.mp3")
            checks['transcription_submission'] = transcript.id is not None
        except Exception as e:
            print(f"Transcription submission failed: {e}")
    
    # 3. Alert if any check fails
    if not all([checks['api_reachable'], checks['transcription_submission']]):
        send_alert(
            severity='critical',
            message=f'AssemblyAI health check failed: {checks}',
            timestamp=datetime.now().isoformat()
        )
    
    # 4. Alert on slow response times
    if checks['response_time_ms'] and checks['response_time_ms'] > 5000:
        send_alert(
            severity='warning',
            message=f'AssemblyAI response time degraded: {checks["response_time_ms"]}ms',
            timestamp=datetime.now().isoformat()
        )
    
    return checks

def send_alert(severity: str, message: str, timestamp: str):
    """
    Send alert to your monitoring system
    """
    # Slack, PagerDuty, email, etc.
    print(f"[{severity.upper()}] {timestamp}: {message}")

Set up monitoring with API Status Check:

• Automated health checks every 60 seconds
• Instant alerts via email, Slack, Discord, or webhook
• Historical uptime and incident tracking
• No code required

7. Communicate Proactively with Users

Status page for your application:

from flask import Flask, jsonify
import redis

app = Flask(__name__)
cache = redis.Redis()

@app.route('/api/status')
def service_status():
    """
    Expose service status to your users
    """
    # Check cached health status
    assemblyai_status = cache.get('assemblyai_health_status')
    
    if assemblyai_status == 'degraded':
        return jsonify({
            'status': 'partial_outage',
            'message': 'Transcription services experiencing delays. Your jobs are queued and will process when service resumes.',
            'affected_services': ['transcription', 'real-time'],
            'eta': 'Monitoring provider status for updates'
        })
    
    return jsonify({
        'status': 'operational',
        'services': ['transcription', 'real-time', 'webhooks']
    })

User notifications:

• In-app banners: "Transcription processing may be delayed"
• Email updates for queued jobs
• Support team briefing with templated responses
• Social media status updates

Frequently Asked Questions

How often does AssemblyAI experience outages?

AssemblyAI maintains strong uptime, typically exceeding 99.9% availability. Major outages affecting all customers are rare (1-4 times per year), though brief regional or feature-specific issues may occur more frequently. Most production users experience minimal disruption in a typical year. Monitor real-time status at apistatuscheck.com/api/assemblyai.

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

The official AssemblyAI status page (status.assemblyai.com) is manually updated by their 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 API endpoints, often detecting issues before they're officially reported. Use both for comprehensive monitoring—official updates for incident details and resolution ETAs, automated monitoring for immediate detection.

Should I use webhooks or polling to check transcription status?

For most applications, implement a hybrid approach: rely on webhooks for normal operation (faster, more efficient) but include scheduled polling as a backup. During outages, webhooks may be delayed or lost. Polling your transcription status every 30-60 seconds ensures you don't miss completions. For mission-critical workflows, polling is essential.

Can I get refunded or SLA credits for AssemblyAI downtime?

AssemblyAI's Terms of Service include availability commitments, but specific SLA terms vary by plan. Enterprise customers with custom agreements typically have defined SLA credits for downtime exceeding thresholds. Free and standard paid tier users should review the Terms of Service or contact AssemblyAI support for clarification on compensation policies.

How accurate is AssemblyAI compared to other speech-to-text providers?

AssemblyAI consistently ranks among the most accurate speech-to-text APIs, often outperforming alternatives in independent benchmarks—particularly for business English, phone calls, and noisy audio. However, accuracy varies by use case. Consider testing multiple providers (Deepgram, OpenAI Whisper) with your specific audio to determine the best fit. Many production applications use AssemblyAI as primary with fallback providers for redundancy.

What should I do if only real-time streaming is down but batch transcription works?

AssemblyAI's real-time and batch transcription systems are separate infrastructure. If only real-time is affected, you can temporarily fall back to batch processing for non-latency-critical use cases, or implement a fallback to Deepgram's real-time streaming (which has excellent low-latency performance). Monitor both systems separately in your health checks.

How do I prevent duplicate transcriptions during retry attempts?

Implement idempotency using your own unique identifiers. Before submitting a transcription, check your database to see if you've already submitted that audio file (using a hash of the audio URL or file). Store the AssemblyAI transcript ID alongside your record. On retries, check if a transcript ID already exists before submitting again.

def idempotent_transcribe(audio_url: str, unique_id: str):
    # Check database for existing transcript
    existing = db.get_transcript_by_id(unique_id)
    if existing and existing.assemblyai_transcript_id:
        # Already submitted, fetch current status
        return transcriber.get_transcript(existing.assemblyai_transcript_id)
    
    # Submit new transcription
    transcript = transcriber.transcribe(audio_url)
    
    # Store transcript ID
    db.save_transcript(unique_id, transcript.id)
    
    return transcript

Does AssemblyAI store my audio files permanently?

No. AssemblyAI stores uploaded audio files temporarily (typically 30 days) and then deletes them. For compliance, auditability, or reprocessing needs, always maintain your own permanent storage of audio files (S3, Google Cloud Storage, etc.). This also allows you to retry transcription if AssemblyAI was down during your initial attempt.

What's the best way to handle speaker diarization failures?

If speaker diarization is failing or degraded, you have several options:

1. Retry with diarization disabled to at least get base transcription
2. Post-process with alternative diarization using libraries like pyannote.audio
3. Fall back to other providers - Deepgram and AWS Transcribe also offer diarization
4. Queue for later processing when AssemblyAI's diarization service recovers

Track diarization-specific failures separately from general transcription failures in your monitoring.

How can I tell if slow transcription is due to AssemblyAI issues or my audio quality?

Compare processing times across multiple audio files of similar length and quality. If you normally see 0.2x real-time processing (a 10-minute file takes 2 minutes) and suddenly all files are taking 10x longer, that indicates AssemblyAI capacity issues. Single slow files are more likely audio quality problems. Check API Status Check for current response time trends across all users.

Stay Ahead of AssemblyAI Outages

Don't let transcription failures catch you off guard. Subscribe to real-time AssemblyAI alerts and get notified instantly when issues are detected—before your users notice.

API Status Check monitors AssemblyAI 24/7 with:

• 60-second health checks for transcription and streaming APIs
• Instant alerts via email, Slack, Discord, or webhook
• Historical uptime tracking and incident reports
• Response time monitoring and latency trends
• Multi-provider monitoring for your entire AI/ML stack

Start monitoring AssemblyAI now →

Related Guides

• Is Deepgram Down? - Alternative speech-to-text provider status
• Is OpenAI Down? - Monitor OpenAI Whisper API and GPT models
• API Monitoring Best Practices - Build resilient AI-powered applications

---

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