Is Twilio Down? Developer's Guide to SMS & Voice API Outages (2026)

Your verification codes aren't sending. Voice calls are failing mid-conversation. SMS messages are stuck in "queued" status. Your support inbox is flooding with "I didn't get the code" tickets. Twilio might be down — and since it's your SMS gateway, voice infrastructure, and 2FA provider all in one, a Twilio outage can lock users out entirely and halt critical communications.

Here's how to confirm it's Twilio, respond immediately, and architect your messaging stack so the next outage doesn't take your user flows down with it.

Is Twilio Actually Down Right Now?

Before you start debugging your webhook signatures or checking account balances, confirm it's a Twilio issue:

1. API Status Check — Twilio — Independent monitoring with response time history
2. Is Twilio Down? — Quick status check with 24h timeline
3. Twilio Official Status — Twilio's status page (typically very transparent)
4. Downdetector — Twilio — Community-reported outages

What Twilio Outages Look Like

Twilio is a multi-service platform spanning SMS, voice, video, messaging, and identity. Knowing which piece is failing changes your response strategy:

Component	Symptoms	Impact
Programmable SMS	Messages stuck in "queued", delivery failures, 21211 errors	SMS/MMS broken
Programmable Voice	Calls fail to connect, dropped mid-call, TwiML fetch timeouts	Voice channels down
Verify API	Verification codes not sending, 60200 errors	2FA/auth flows blocked
SendGrid	Email delivery delays, API 500 errors	Transactional email down
Messaging Services	Short code/toll-free delivery failures	Bulk messaging broken
Phone Numbers	Lookup/provisioning API errors	Can't acquire numbers
Conversations API	Message history unavailable, webhooks delayed	Chat features degraded
REST API	503 errors, elevated latency on API calls	Full platform impact

Key insight: Twilio's infrastructure is carrier-dependent. SMS outages can be carrier-specific (e.g., Verizon deliveries failing while AT&T works) or geographic (US-based numbers working while international fails). Always check YOUR specific use case.

Recent Twilio Incidents

• Dec 2025 — Brief Verify API degradation in US-1 region (~45 min), verification codes delayed 2-5 minutes
• Oct 2025 — SendGrid (Twilio-owned) experienced elevated email delivery delays for EU customers
• Aug 2025 — Programmable Voice partial outage affecting call connection rates in APAC
• Jun 2025 — SMS delivery delays to T-Mobile USA due to carrier-side filtering changes

Twilio is generally reliable (99.95% historical uptime), but when it goes down, the impact is immediate and user-facing.

Architecture Patterns for Twilio Resilience

Queue-Based Messaging Architecture

Never send SMS synchronously in user-facing request paths. Use a queue:

// User-facing API endpoint
app.post('/api/send-verification', async (req, res) => {
  const { phoneNumber, userId } = req.body
  
  // Don't wait for Twilio — queue it
  await messageQueue.add('send-sms', {
    to: phoneNumber,
    body: `Your code: ${generateCode()}`,
    userId,
    priority: 'high',
  })
  
  // Respond immediately
  res.json({ queued: true })
})

// Background worker processes the queue
messageQueue.process('send-sms', async (job) => {
  const { to, body, userId } = job.data
  
  const result = await sendSMSResilient(to, body)
  
  if (!result.success) {
    // Retry with exponential backoff
    throw new Error('SMS failed, will retry')
  }
  
  await db.users.update({
    where: { id: userId },
    data: { lastSMSSentAt: new Date() },
  })
})

Status Callback Monitoring

Twilio provides status callbacks for message delivery. Use them to detect issues early:

// Webhook endpoint for Twilio status callbacks
app.post('/webhooks/twilio/message-status', async (req, res) => {
  const { MessageSid, MessageStatus, To, ErrorCode } = req.body
  
  await db.smsDelivery.upsert({
    where: { messageSid: MessageSid },
    create: {
      messageSid: MessageSid,
      status: MessageStatus,
      to: To,
      errorCode: ErrorCode,
    },
    update: {
      status: MessageStatus,
      errorCode: ErrorCode,
      updatedAt: new Date(),
    },
  })
  
  // Alert on elevated failure rates
  const recentFailures = await db.smsDelivery.count({
    where: {
      status: { in: ['failed', 'undelivered'] },
      createdAt: { gte: new Date(Date.now() - 5 * 60 * 1000) }, // last 5min
    },
  })
  
  if (recentFailures > 10) {
    await alertOps('High SMS failure rate detected - check Twilio status')
  }
  
  res.sendStatus(200)
})

Configure callbacks when creating messages:

const message = await client.messages.create({
  to,
  from: process.env.TWILIO_PHONE_NUMBER!,
  body,
  statusCallback: 'https://yourapp.com/webhooks/twilio/message-status',
})

Geographic Redundancy for Voice

For critical voice applications, use multiple Twilio regions:

// Provision numbers in multiple regions
const regions = ['us1', 'au1', 'ie1']
const regionalNumbers = {}

for (const region of regions) {
  const number = await client.incomingPhoneNumbers.create({
    phoneNumber: '+1234567890', // Your number
    voiceUrl: `https://${region}.yourapp.com/voice`,
    region,
  })
  regionalNumbers[region] = number.phoneNumber
}

// Route calls based on user location or availability
function getVoiceNumber(userCountry: string) {
  const regionMap = {
    US: 'us1',
    AU: 'au1',
    EU: 'ie1',
  }
  return regionalNumbers[regionMap[userCountry]] || regionalNumbers['us1']
}

---

Monitoring Twilio Proactively

Don't wait for users to report delivery issues. Build monitoring into your stack:

Health Check Endpoint

// API route: /api/health/twilio
export async function GET() {
  const checks = {
    api: false,
    sms: false,
    verify: false,
    voice: false,
    timestamp: new Date().toISOString(),
  }
  
  try {
    // Test API connectivity
    await client.api.accounts(process.env.TWILIO_ACCOUNT_SID!).fetch()
    checks.api = true
  } catch (error) {
    console.error('Twilio API check failed:', error)
  }
  
  try {
    // Test SMS (send to your monitoring number)
    const message = await client.messages.create({
      to: process.env.MONITORING_PHONE_NUMBER!,
      from: process.env.TWILIO_PHONE_NUMBER!,
      body: `Health check ${Date.now()}`,
    })
    checks.sms = message.status !== 'failed'
  } catch (error) {
    console.error('Twilio SMS check failed:', error)
  }
  
  try {
    // Test Verify service availability
    const services = await client.verify.v2.services.list({ limit: 1 })
    checks.verify = services.length > 0
  } catch (error) {
    console.error('Twilio Verify check failed:', error)
  }
  
  const allHealthy = Object.values(checks).slice(0, -1).every(v => v === true)
  
  return Response.json(checks, { status: allHealthy ? 200 : 503 })
}

Delivery Rate Monitoring

Track your actual delivery rates and alert on anomalies:

async function checkDeliveryRates() {
  const last15min = new Date(Date.now() - 15 * 60 * 1000)
  
  const stats = await db.smsDelivery.groupBy({
    by: ['status'],
    where: { createdAt: { gte: last15min } },
    _count: true,
  })
  
  const total = stats.reduce((sum, s) => sum + s._count, 0)
  const failed = stats.find(s => ['failed', 'undelivered'].includes(s.status))?._count || 0
  const failureRate = total > 0 ? (failed / total) * 100 : 0
  
  // Alert if failure rate exceeds 5%
  if (failureRate > 5 && total > 20) {
    await alertOps(`SMS failure rate: ${failureRate.toFixed(1)}% (${failed}/${total} in last 15min)`)
  }
  
  return { total, failed, failureRate }
}

// Run every 5 minutes
setInterval(checkDeliveryRates, 5 * 60 * 1000)

---

Common Twilio Error Codes

Error	Meaning	Fix
20003	Authentication failed	Check Account SID and Auth Token
21211	Invalid 'To' phone number	Validate phone format (E.164)
21608	Unverified number (trial account)	Verify number or upgrade account
21610	Blacklisted number	Recipient opted out or blocked
30003	Unreachable destination	Phone off, no signal, or carrier issue
30005	Unknown destination	Invalid number
30007	Message filtered/blocked	Carrier spam filter triggered
60200	Verification service unavailable	Fallback to manual SMS codes
63016	Concurrent request limit	Rate limiting, implement backoff
53000	Voice call failed to connect	Check TwiML URL or destination
20429	Too many requests	Implement exponential backoff

Critical insight: Error 30007 (filtered) is increasingly common due to carrier-side spam filtering. Use registered toll-free/short codes for bulk messaging, avoid spam trigger words, and implement proper opt-in flows.

---

Twilio vs. Multi-Provider Architecture: The Tradeoff

When Twilio goes down, some teams consider adding backup providers permanently. Here's the reality:

Single provider (Twilio only):

• ✅ Simpler codebase, one integration
• ✅ Unified analytics and phone number management
• ✅ Rich feature set (Verify, Conversations, Flex)
• ❌ Single point of failure
• ❌ Vulnerable to carrier-specific issues

Multi-provider architecture:

• ✅ Resilience against any single provider's outages
• ✅ Can optimize pricing per message type
• ✅ Geographic redundancy built-in
• ❌ More complex integration and testing
• ❌ Managing multiple phone numbers/accounts
• ❌ Inconsistent feature sets across providers

The pragmatic approach: Start with Twilio + queue-based architecture + proper retry logic. Add a second provider (Vonage or MessageBird) ONLY for critical flows like 2FA. Don't over-engineer multi-provider for every SMS — focus on resilience patterns that handle 95% of issues without the complexity.

For enterprise applications handling millions of messages, multi-provider is essential. For most startups/scale-ups, robust Twilio integration beats brittle multi-provider code.

---

Frequently Asked Questions

Q: How long do Twilio outages typically last?
A: Most Twilio incidents resolve within 30-60 minutes. Major outages are rare and usually affect specific services or regions rather than the entire platform.

Q: Will queued messages send once Twilio recovers?
A: Messages in "queued" status will attempt delivery for up to 4 hours. After that, they're marked as "failed". Implement your own queue layer for better control.

Q: Should I switch from Twilio Verify to manual SMS codes?
A: No. Twilio Verify handles rate limiting, fraud detection, and international delivery nuances better than manual implementation. Use Verify with a manual SMS fallback.

Q: Can I use AWS SNS as a Twilio backup?
A: Yes, but SNS requires phone numbers from each carrier. For programmatic fallback, Vonage or MessageBird are easier to integrate as secondary providers.

Q: What's the best way to test Twilio outage scenarios?
A: Use Twilio's test credentials to simulate errors, or temporarily block Twilio API IPs in your firewall to test fallback behavior.

---

Get Notified Before Your Users Do

Stop finding out about Twilio outages from user complaints:

1. Bookmark apistatuscheck.com/api/twilio for real-time status
2. Set up Discord/Slack alerts via API Status Check integrations
3. Subscribe to status.twilio.com for official updates
4. Add the health check endpoint above to your monitoring stack
5. Monitor delivery rates — often you'll spot issues before Twilio reports them

Twilio is mission-critical infrastructure. The teams that handle outages best aren't the ones with the most monitoring — they're the ones whose users never notice because the fallbacks kicked in automatically.

---

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