Stripe Failed Payment Retry: Complete Technical Guide

How Stripe's Default Retry Logic Works

When a subscription payment fails in Stripe, the platform automatically attempts to retry the charge. Here's what happens:

Stripe's Default Retry Schedule

What Happens During a Retry

1. 1. Payment attempt: Stripe attempts to charge the same card that failed previously
2. 2. Webhook fired: invoice.payment_action_required or invoice.payment_failed
3. 3. Email sent (optional): Stripe can email customers about the failure
4. 4. Subscription state updated: Remains past_due if retry fails

The Problem with Stripe's Default Retries

Stripe's one-size-fits-all approach has major limitations:

Understanding Stripe Decline Codes

When a payment fails, Stripe returns a decline code that explains why. This is your roadmap for building smarter retry logic.

Common Decline Codes & What They Mean

How to Access Decline Codes

In the Stripe API, decline codes are returned in the charge object:

{
  "id": "ch_3ABC...",
  "object": "charge",
  "status": "failed",
  "failure_code": "insufficient_funds",
  "failure_message": "Your card has insufficient funds.",
  "outcome": {
    "type": "issuer_declined",
    "reason": "insufficient_funds"
  }
}

You can also view decline codes in the Stripe Dashboard → Payments → [Failed Payment] → "Decline reason".

Building Smart Retry Logic

To achieve the industry benchmark of 85-94% recovery (vs Stripe's 30%), you need decline code-aware retry logic.

Smart Retry Schedule by Decline Code

Implementation Options

You have three options for implementing smart retries:

Option 1: Configure Stripe's Retry Rules

In Stripe Dashboard → Settings → Billing → Subscriptions and emails, you can customize:

• • Number of retry attempts (1-4)
• • Days between retries
• • Email notifications to customers

Pros: Easy, no code required
Cons: Still one-size-fits-all, doesn't adapt to decline codes

Option 2: Build Custom Retry Logic with Webhooks

Listen to Stripe webhooks and trigger manual retries based on decline codes:

// Example: Node.js webhook handler
app.post('/stripe-webhook', async (req, res) => {
  const event = req.body;
  
  if (event.type === 'invoice.payment_failed') {
    const invoice = event.data.object;
    const charge = invoice.charge;
    const declineCode = charge.failure_code;
    
    // Smart retry logic
    if (declineCode === 'insufficient_funds') {
      scheduleRetry(invoice.id, 3 * 24 * 60 * 60 * 1000); // 3 days
    } else if (declineCode === 'card_declined') {
      scheduleRetry(invoice.id, 4 * 60 * 60 * 1000); // 4 hours
    } else if (declineCode === 'expired_card') {
      sendDunningEmail(invoice.customer);
    }
  }
  
  res.status(200).send('OK');
});

Pros: Full control, adapts to decline codes
Cons: Requires development time, ongoing maintenance

Option 3: Use a Payment Recovery Tool (Like Revive)

Tools like Revive handle smart retries automatically:

• ✅ Decline code-aware retry schedules
• ✅ Automated dunning emails
• ✅ Real-time recovery analytics
• ✅ No code required

Pros: Zero setup, designed for industry-leading recovery rates, no engineering time
Cons: Monthly cost (but ROI is typically 10-50x)

Webhook Events You Need to Track

If you're building custom retry logic, listen to these Stripe webhook events:

Example Webhook Payload

{
  "type": "invoice.payment_failed",
  "data": {
    "object": {
      "id": "in_1ABC...",
      "customer": "cus_XYZ...",
      "subscription": "sub_123...",
      "amount_due": 2900,
      "attempt_count": 1,
      "charge": {
        "id": "ch_3DEF...",
        "failure_code": "insufficient_funds",
        "failure_message": "Your card has insufficient funds."
      }
    }
  }
}

Advanced Strategies

1. Vary Retry Time of Day

A charge that fails at 2 AM might succeed at 10 AM (when banks are more lenient with daily limits). Spread retries across different times:

• 1st retry: 10 AM (morning when balances are higher)
• 2nd retry: 2 PM (afternoon)
• 3rd retry: 8 PM (evening after work hours)

2. Enable Stripe's Network Tokens

Network tokens automatically update expired card details and increase authorization rates. Enable in Stripe Dashboard → Settings → Payments → Network tokens.

Impact: Reduces expired card failures by 50%+

3. Use Card Account Updater

Visa and Mastercard automatically provide new card details when cards expire. Enable in Stripe Dashboard → Settings → Billing → Card account updater.

Impact: Reduces expired card failures by 30-40%

4. Retry with Backup Payment Methods

If you've collected multiple payment methods from customers, try the backup method when the primary fails:

// After primary card fails
if (customer.backup_payment_method) {
  stripe.invoices.pay(invoice.id, {
    payment_method: customer.backup_payment_method
  });
}

Dunning Management with Stripe

Payment retries alone won't recover expired cards or persistent failures. You need dunning emails to prompt customer action.

Stripe's Built-In Dunning Emails

Stripe can send automatic emails when payments fail. Configure in Dashboard → Settings → Billing → Emails:

• ✅ Payment failed notification
• ✅ Upcoming invoice reminders
• ✅ Subscription canceled notification

Limitation: Stripe's emails are generic and not customizable. They have low open rates (~13%) and poor conversion.

Custom Dunning Emails (Better Approach)

Disable Stripe's default emails and send your own branded emails:

1. 1. Disable Stripe emails: Dashboard → Settings → Billing → Emails → Turn off
2. 2. Listen to webhooks: invoice.payment_failed
3. 3. Generate card update link: Use Stripe Checkout in setup mode
4. 4. Send branded email: Via SendGrid, Postmark, etc.

// Generate card update link
const session = await stripe.checkout.sessions.create({
  mode: 'setup',
  customer: 'cus_ABC...',
  success_url: 'https://yourapp.com/billing/success',
  cancel_url: 'https://yourapp.com/billing'
});

// session.url is the one-click card update link
sendEmail({
  to: customer.email,
  subject: 'Payment update needed',
  body: `Click here to update: ${session.url}`
});

Monitoring & Analytics

Track these metrics to optimize your retry strategy:

Where to View Metrics in Stripe

• Failed payments: Dashboard → Payments → Filter by "Failed"
• Decline codes: Click on any failed payment → "Decline reason"
• Recovery trends: Dashboard → Analytics → Payment retries (if available)

Key Takeaways

• 💡 Stripe's default retry logic recovers only 30% of failed payments
• 💡 Decline codes tell you WHY a payment failed — use them to build smarter retries
• 💡 Expired cards should never be retried — send dunning emails immediately
• 💡 Insufficient funds needs 3-7 day delays to align with payday
• 💡 Custom retry logic via webhooks can help achieve the industry benchmark of 85-94% recovery
• 💡 Enable Card Account Updater and Network Tokens to prevent failures
• 💡 Track recovery rate by decline code to optimize your strategy

The bottom line: Stripe's default retries are a good starting point, but not optimized for maximum recovery. By understanding decline codes and implementing smart retry logic, you can recover 3x more failed payments (studies show 85-94% is achievable) and save thousands in MRR every month.