Is Square Down? Complete Guide to Square POS, Payments API & Cash App Outages (2026)

by API Status Check

TLDR: Check if Square is down at apistatuscheck.com/api/square. This guide covers Square POS, Payments API, and Cash App outage detection, plus how to keep processing payments during Square downtime.

TLDR: When Square goes down, check status.squareup.com and apistatuscheck.com/api/square. Keep selling with offline mode on Square terminals, backup payment processors (Stripe, PayPal), and manual card imprinters for physical locations. Multi-processor architecture prevents complete revenue loss during outages.

Your Square terminal just declined a payment. Then another. Your online checkout is throwing errors. Your support line is lighting up. Square might be down — and for merchants relying on Square's ecosystem, this means revenue grinding to a halt at physical locations and online stores simultaneously.

Square outages are uniquely disruptive because the platform touches so many parts of modern commerce: in-person POS systems, e-commerce checkouts, payment APIs powering apps, and Cash App Business accounts handling instant payments. Here's how to quickly diagnose Square issues, implement resilient payment flows, and keep selling when Square has problems.

Is Square Actually Down Right Now?

Before you troubleshoot your integration or reboot hardware, confirm it's a Square-side issue:

  1. API Status Check — Square — Independent monitoring with real-time status and response times
  2. Is Square Down? — Quick status check with 24-hour incident history
  3. Square Official Status — Square's status page covering all services
  4. Downdetector — Square — Community-reported outages with geographic heatmaps
  5. Cash App Status — Separate status for Cash App Business

Understanding Square's Service Architecture

Square isn't a monolithic service. Different components can fail independently, creating partial outages:

Service What It Does When It Fails
Square POS Physical terminals, iPad POS In-person sales stop
Square Online E-commerce storefronts Online orders fail
Payments API Developer integrations Apps can't process payments
Reader SDK Mobile card readers Mobile payments fail
Cash App Business Instant payments via Cash App P2P business payments blocked
Invoices API Send/track invoices Can't create or send invoices
Square Dashboard Merchant portal Can't view sales, refund, or configure
Webhooks Event notifications Apps miss payment confirmations
Square Banking Business checking/savings Can't access funds
Payroll Employee payment processing Paychecks delayed

Critical insight: Square's POS terminals have limited offline mode for card-present transactions. If your terminal is declining cards during an outage, this fallback should still work — unless the network itself is unreachable.

Common Square Error Codes During Outages

Error Meaning Action
SERVICE_UNAVAILABLE Square API temporarily down Retry with exponential backoff
INTERNAL_SERVER_ERROR Square internal issue Transient, retry after delay
GATEWAY_TIMEOUT Square upstream timeout API overloaded or degraded
CONFLICT Idempotency key conflict Previous request still processing
BAD_REQUEST with cryptic message Possible service degradation Check status page
Terminal: "Connection Error" POS can't reach Square Network or Square outage
Terminal: "Processing..." (hangs) Payment stuck Square processing delays

For Developers: Building Resilient Square Integrations

1. Idempotency Keys Are Non-Negotiable

Square's Payments API requires idempotency keys for all payment creation requests to prevent duplicate charges:

import { Client, Environment } from 'square'
import { v4 as uuidv4 } from 'uuid'

const client = new Client({
  accessToken: process.env.SQUARE_ACCESS_TOKEN!,
  environment: Environment.Production,
})

async function createPaymentWithRetry(
  amount: number,
  sourceId: string,
  orderId: string,
  maxRetries = 3
) {
  // Generate idempotency key once per logical payment
  const idempotencyKey = `order_${orderId}_${Date.now()}`
  
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const { result } = await client.paymentsApi.createPayment({
        sourceId,
        amountMoney: {
          amount: BigInt(amount),
          currency: 'USD',
        },
        idempotencyKey,
        referenceId: orderId,
        note: `Order ${orderId}`,
      })
      
      return result.payment
    } catch (error: any) {
      // Don't retry client errors
      if (error.statusCode >= 400 && error.statusCode < 500) {
        throw error
      }
      
      // Retry server errors and network failures
      if (attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000 + Math.random() * 500
        console.warn(`Square attempt ${attempt + 1} failed: ${error.message}. Retrying in ${Math.round(delay)}ms`)
        await new Promise(r => setTimeout(r, delay))
      } else {
        throw new Error(`Square payment failed after ${maxRetries} retries: ${error.message}`)
      }
    }
  }
}

Why this matters: During partial outages, your first request might timeout but still process on Square's side. Without idempotency keys, retrying creates duplicate charges. With them, Square guarantees the payment is only created once.

2. Queue-Based Payment Processing

Don't call Square synchronously during checkout — queue payments for async processing with automatic retries:

import { Queue, Worker } from 'bullmq'
import { Redis } from 'ioredis'

const redis = new Redis()
const paymentQueue = new Queue('square-payments', { connection: redis })

// Checkout endpoint: accept order immediately
app.post('/checkout', async (req, res) => {
  const order = await db.orders.create({
    status: 'pending_payment',
    amount: req.body.amount,
    customerId: req.body.customerId,
    items: req.body.items,
  })
  
  // Queue payment for async processing
  await paymentQueue.add('process-payment', {
    orderId: order.id,
    amount: order.amount,
    sourceId: req.body.sourceId,
  }, {
    attempts: 5,
    backoff: {
      type: 'exponential',
      delay: 3000, // Start with 3s, double each retry
    },
    removeOnComplete: 100, // Keep last 100 completed
    removeOnFail: 500, // Keep last 500 failed for debugging
  })
  
  res.json({ 
    orderId: order.id, 
    status: 'processing',
    message: 'Payment processing, you will receive confirmation shortly'
  })
})

// Worker: process payments with automatic retries
const worker = new Worker('square-payments', async (job) => {
  const { orderId, amount, sourceId } = job.data
  
  try {
    const payment = await createPaymentWithRetry(amount, sourceId, orderId)
    
    await db.orders.update(orderId, {
      status: 'paid',
      squarePaymentId: payment.id,
      paidAt: new Date(),
    })
    
    // Send confirmation email
    await sendEmail(orderId, 'payment-success')
    
    return { success: true, paymentId: payment.id }
  } catch (error: any) {
    // Log failure for manual review
    await db.paymentFailures.create({
      orderId,
      error: error.message,
      timestamp: new Date(),
    })
    
    throw error // BullMQ will retry based on config
  }
}, { connection: redis })

worker.on('failed', async (job, err) => {
  // After all retries exhausted, alert ops
  if (job?.attemptsMade === 5) {
    await alertOps(`Square payment failed for order ${job.data.orderId} after 5 attempts: ${err.message}`)
  }
})

During an outage: Orders queue up. When Square recovers, payments process automatically. No lost sales, no manual intervention.

3. Webhook Resilience and Reconciliation

Square webhooks are your source of truth, but they can be delayed or duplicated during outages:

import crypto from 'crypto'

app.post('/webhooks/square', async (req, res) => {
  // Verify webhook signature
  const signature = req.headers['x-square-signature'] as string
  const body = JSON.stringify(req.body)
  
  const hmac = crypto.createHmac('sha256', process.env.SQUARE_WEBHOOK_SIGNATURE_KEY!)
  hmac.update(body)
  const expectedSignature = hmac.digest('base64')
  
  if (signature !== expectedSignature) {
    return res.status(400).json({ error: 'Invalid signature' })
  }
  
  const event = req.body
  
  // Deduplicate: Square may re-deliver during recovery
  const processed = await redis.get(`square_event:${event.event_id}`)
  if (processed) {
    return res.json({ received: true, deduplicated: true })
  }
  
  try {
    await handleSquareEvent(event)
    // Mark as processed with 7-day TTL
    await redis.set(`square_event:${event.event_id}`, '1', 'EX', 604800)
  } catch (error) {
    console.error(`Failed to process Square webhook ${event.type}:`, error)
    return res.status(500).json({ error: 'Processing failed' })
  }
  
  res.json({ received: true })
})

// Reconciliation job: run every 10 minutes
async function reconcileSquarePayments() {
  const stuckOrders = await db.orders.find({
    status: 'pending_payment',
    createdAt: { $lt: new Date(Date.now() - 15 * 60 * 1000) }, // 15+ min old
    squarePaymentId: { $exists: true }
  })
  
  for (const order of stuckOrders) {
    try {
      const { result } = await client.paymentsApi.getPayment(order.squarePaymentId)
      const payment = result.payment!
      
      if (payment.status === 'COMPLETED') {
        await db.orders.update(order.id, { status: 'paid' })
        console.log(`Reconciled order ${order.id} — payment completed`)
      } else if (['FAILED', 'CANCELED'].includes(payment.status!)) {
        await db.orders.update(order.id, { status: 'failed' })
      }
      // If PENDING or APPROVED, leave it — Square is still processing
    } catch (error: any) {
      console.warn(`Can't reconcile order ${order.id}: ${error.message}`)
      // Square API might still be down — catch on next run
    }
  }
}

4. Multi-Region Failover (Advanced)

For mission-critical applications, consider multi-processor failover:

interface PaymentProcessor {
  createPayment(amount: number, source: string): Promise<{ id: string }>
  healthCheck(): Promise<boolean>
}

class SquareProcessor implements PaymentProcessor {
  async createPayment(amount: number, source: string) {
    // Square implementation
  }
  
  async healthCheck() {
    try {
      await client.locationsApi.listLocations()
      return true
    } catch {
      return false
    }
  }
}

class StripeProcessor implements PaymentProcessor {
  async createPayment(amount: number, source: string) {
    // Stripe implementation
  }
  
  async healthCheck() {
    try {
      await stripe.charges.list({ limit: 1 })
      return true
    } catch {
      return false
    }
  }
}

const processors = [new SquareProcessor(), new StripeProcessor()]

async function processPaymentWithFailover(amount: number, source: string) {
  for (const processor of processors) {
    if (await processor.healthCheck()) {
      try {
        return await processor.createPayment(amount, source)
      } catch (error) {
        console.warn(`${processor.constructor.name} failed, trying next processor`)
      }
    }
  }
  throw new Error('All payment processors unavailable')
}

Warning: Multi-processor setups are complex. You'll need to handle different card tokens, reconcile across systems, and manage PCI compliance for each. Only worth it for high-volume businesses where downtime is extremely costly.

Monitoring Square Proactively

Payment Health Metrics

Track these metrics to catch Square issues before customers complain:

// Instrument all Square API calls
const squareMetrics = {
  async trackPayment(
    result: 'success' | 'failure' | 'timeout',
    durationMs: number,
    errorCode?: string
  ) {
    await metrics.increment('square.payment.result', 1, { result })
    await metrics.histogram('square.payment.duration_ms', durationMs)
    
    if (errorCode) {
      await metrics.increment('square.payment.error', 1, { code: errorCode })
    }
  }
}

// Alert rules to set up:
// - square.payment.failure_rate > 10% for 3 minutes → page on-call
// - square.payment.duration_ms p95 > 8000 → warning (slow API)
// - square.payment.error{code=SERVICE_UNAVAILABLE} > 5 in 1 min → critical
// - square.payment.success count drops to 0 for 5 min → critical

Status Page Monitoring

Set up automated monitoring:

  1. API Status Check — Real-time monitoring with Discord/Slack notifications
  2. issquareup.com — Square's official status page (subscribe to updates)
  3. Your own health checks:
    // Ping Square API every minute
async function checkSquareHealth() {
  try {
    const start = Date.now()
    await client.locationsApi.listLocations()
    const duration = Date.now() - start
    
    await metrics.histogram('square.health_check.duration_ms', duration)
    await metrics.gauge('square.health_check.status', 1) // Up
  } catch (error) {
    await metrics.gauge('square.health_check.status', 0) // Down
    await alertOps('Square API health check failed')
  }
}

The "Square Is Down" Troubleshooting Checklist

When you suspect a Square outage, work through this systematically:

Step 1: Verify It's Actually Square

  1. Check apistatuscheck.com/api/square — Is Square reporting issues?
  2. Check issquareup.com — Does Square acknowledge the outage?
  3. Check Downdetector — Are other merchants reporting issues?

Step 2: Test Minimal API Call

# Test Square API directly
curl https://connect.squareup.com/v2/locations \
  -H "Square-Version: 2024-12-01" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

If this times out or returns 503, Square is definitely down.

Step 3: Check Your Infrastructure

  • Webhooks: Can Square reach your webhook endpoint? Check webhook logs in Square Dashboard.
  • Network: Can you reach connect.squareup.com from your server?
    ping connect.squareup.com
curl -I https://connect.squareup.com
  • Rate limits: Have you hit API rate limits? (Standard: 10 requests/second per location)

Step 4: POS Terminal Specific

If terminals aren't working:

  1. Check Wi-Fi/cellular connection on the terminal
  2. Restart the terminal (hold power button)
  3. Check Square Dashboard to see if terminal shows as offline
  4. Try offline mode (swipe/dip/tap only)
  5. Try a different terminal if you have one

Step 5: Square Online Specific

If your online store checkout fails:

  1. Test checkout yourself with a test card
  2. Check browser console for JavaScript errors
  3. Verify Square Web Payments SDK is loading
  4. Check if your Square Online site is published (not in draft mode)

What NOT to Do During a Square Outage

  • ❌ Don't switch payment processors mid-outage — Creates reconciliation nightmares and you'll lose historical data
  • ❌ Don't retry payments without idempotency keys — Risk double-charging customers
  • ❌ Don't reboot POS hardware repeatedly — Wastes time, use offline mode instead
  • ❌ Don't panic-refund everything — Wait for the outage to resolve, then reconcile
  • ❌ Don't key in card numbers manually on POS — Fails without connection, higher fraud risk, higher fees
  • ❌ Don't disable your online checkout — Queue orders and display a message instead

Alternative Payment Processors (If You Need to Switch)

If Square outages are frequent or you need redundancy, consider:

Processor Best For Developer Experience Uptime
Stripe Online, API-first businesses Excellent docs, best API Very reliable
PayPal Consumer-facing e-commerce Moderate, legacy API Good
Adyen Enterprise, international Complex but powerful Excellent
Clover Retail POS, restaurants Closed ecosystem Good
Toast Restaurants specifically Industry-specific features Good
Shopify Payments Shopify stores only Integrated with Shopify Good

Migration complexity: Switching payment processors is hard. You'll need to:

  • Update all card vault data (can't transfer tokens)
  • Rebuild integrations
  • Migrate historical transaction data
  • Update POS hardware (if physical locations)
  • Retrain staff on new systems

Only worth it if Square's downtime is costing you significant revenue regularly.

Cash App Business Specific Issues

Cash App Business runs on separate infrastructure from Square Payments API. If Cash App Business is down but Square POS works, check:

  1. Cash App Status — Separate from Square status
  2. Your Cash App Business Dashboard — Verify your account isn't flagged or suspended
  3. Customer's Cash App — Make sure they have funds and their app is updated

Cash App Business outages are rare but when they happen, fallback to:

  • Regular Square terminal payments
  • Venmo/Zelle as alternative P2P
  • Cash or manual invoicing

Get Notified Before Your Customers Complain

Every minute of a Square outage means lost sales. Set up monitoring now:

  1. Bookmark apistatuscheck.com/api/square for real-time status
  2. Set up instant alerts via API Status Check integrations — Discord, Slack, email, webhooks
  3. Subscribe to issquareup.com for official Square updates
  4. Enable Square POS offline mode on all terminals (check settings)
  5. Instrument your payment flow — track success rates, latency, error codes
  6. Test your queue-based payment system — make sure retries work before you need them

The best payment architecture isn't one that never fails — it's one that queues orders, retries automatically, and keeps your business running when Square has problems.

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

Monitor Your APIs

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

View API Status →