# How to check pending payouts in Stripe

- Tool: Stripe
- Difficulty: Beginner
- Time required: 10 minutes
- Compatibility: Stripe API v2024-12+, Node.js 18+
- Last updated: March 2026

## TL;DR

Check pending Stripe payouts in Dashboard → Balance → Payouts tab. Each payout shows its status: pending, in_transit, paid, failed, or canceled. Via the API, use stripe.payouts.list() filtered by status and stripe.balance.retrieve() to see available vs. pending funds. Track payout delivery by listening to payout.paid and payout.failed webhook events.

## Understanding Stripe Payout Statuses

Stripe payouts go through several statuses: pending (scheduled but not yet initiated), in_transit (sent to your bank), paid (confirmed delivered), failed (rejected by the bank), or canceled. Monitoring these statuses helps you reconcile your books, predict cash flow, and catch failed payouts quickly. You can check statuses in the Dashboard, via the API, or by listening to webhook events.

## Before you start

- A verified Stripe account with payouts enabled
- At least one payout initiated (or a payment processed that triggers automatic payout)
- Node.js 18+ for API examples

## Step-by-step guide

### 1. Check payouts in the Dashboard

Go to Stripe Dashboard → Balance. The overview shows your available balance, pending balance, and in-transit funds. Click the 'Payouts' tab to see a list of all payouts with their status, amount, arrival date, and destination bank account.

**Expected result:** You can see all payouts with their current status and expected arrival dates.

### 2. Understand payout statuses

Each payout has one of five statuses: 'pending' means it's scheduled but not yet sent; 'in_transit' means Stripe has sent it to your bank; 'paid' means your bank has confirmed receipt; 'failed' means the bank rejected it; 'canceled' means it was manually canceled before being sent.

**Expected result:** You understand what each status means and can interpret the payout timeline.

### 3. List pending payouts via the API

Use stripe.payouts.list() with a status filter to find pending or in-transit payouts programmatically.

```
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

// List pending payouts
const pending = await stripe.payouts.list({
  status: 'pending',
  limit: 10,
});

pending.data.forEach(p => {
  console.log(`${p.id} | $${p.amount / 100} ${p.currency.toUpperCase()} | ETA: ${new Date(p.arrival_date * 1000).toLocaleDateString()}`);
});
```

**Expected result:** A list of pending payouts with amounts and expected arrival dates.

### 4. Check your balance breakdown

The balance API shows how much is available for payout, how much is pending (from recent charges not yet settled), and how much is in transit (payouts already sent to your bank).

```
const balance = await stripe.balance.retrieve();

console.log('=== Available (ready to pay out) ===');
balance.available.forEach(b => console.log(`  ${b.amount / 100} ${b.currency.toUpperCase()}`));

console.log('=== Pending (from recent charges) ===');
balance.pending.forEach(b => console.log(`  ${b.amount / 100} ${b.currency.toUpperCase()}`));
```

**Expected result:** A clear view of your available vs. pending balance, showing how much can be paid out now.

### 5. Track payout delivery with webhooks

Set up webhooks for payout.paid (successful delivery) and payout.failed (bank rejected) to track payouts in real time. RapidDev teams use these webhooks to update financial dashboards and trigger alerts for failed payouts.

```
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['stripe-signature'];
  const event = stripe.webhooks.constructEvent(
    req.body, sig, process.env.STRIPE_WEBHOOK_SECRET
  );

  switch (event.type) {
    case 'payout.paid':
      const paid = event.data.object;
      console.log(`Payout ${paid.id} delivered: $${paid.amount / 100}`);
      break;
    case 'payout.failed':
      const failed = event.data.object;
      console.log(`Payout ${failed.id} FAILED: ${failed.failure_message}`);
      // Alert team, update records
      break;
  }

  res.json({ received: true });
});
```

**Expected result:** Your server receives real-time notifications when payouts are delivered or fail.

## Complete code example

File: `payout-tracker.js`

```javascript
require('dotenv').config();
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

async function getPayoutSummary() {
  const balance = await stripe.balance.retrieve();

  console.log('=== Balance Summary ===');
  balance.available.forEach(b => {
    console.log(`Available: ${(b.amount / 100).toFixed(2)} ${b.currency.toUpperCase()}`);
  });
  balance.pending.forEach(b => {
    console.log(`Pending:   ${(b.amount / 100).toFixed(2)} ${b.currency.toUpperCase()}`);
  });

  // List recent payouts by status
  const statuses = ['pending', 'in_transit', 'paid', 'failed'];

  for (const status of statuses) {
    const payouts = await stripe.payouts.list({ status, limit: 5 });
    if (payouts.data.length > 0) {
      console.log(`\n=== ${status.toUpperCase()} Payouts ===`);
      payouts.data.forEach(p => {
        const arrival = new Date(p.arrival_date * 1000).toLocaleDateString();
        console.log(
          `  ${p.id} | ${(p.amount / 100).toFixed(2)} ${p.currency.toUpperCase()} | ` +
          `Arrives: ${arrival}${p.failure_message ? ' | FAILED: ' + p.failure_message : ''}`
        );
      });
    }
  }
}

async function getPayoutDetails(payoutId) {
  const payout = await stripe.payouts.retrieve(payoutId);
  console.log('Payout details:', {
    id: payout.id,
    amount: payout.amount / 100,
    currency: payout.currency,
    status: payout.status,
    arrival_date: new Date(payout.arrival_date * 1000).toLocaleDateString(),
    failure_message: payout.failure_message,
    method: payout.method,
    type: payout.type,
  });
  return payout;
}

module.exports = { getPayoutSummary, getPayoutDetails };

// Run directly
if (require.main === module) {
  getPayoutSummary().catch(console.error);
}
```

## Common mistakes

- **Confusing 'pending balance' with 'pending payouts'** — undefined Fix: Pending balance = funds from recent charges not yet settled (takes 2 days). Pending payouts = scheduled payouts waiting to be sent to your bank. These are different concepts.
- **Not monitoring payout.failed webhook events** — undefined Fix: Failed payouts mean money isn't reaching your bank. Listen for payout.failed events and alert your team immediately. Check the failure_message for the reason.
- **Expecting payouts to arrive on weekends or holidays** — undefined Fix: Payouts only process on business days. Payouts scheduled for weekends or holidays arrive on the next business day.
- **Not using pagination when listing many payouts** — undefined Fix: The API returns a maximum of 100 payouts per request. Use has_more and starting_after to paginate through all results.

## Best practices

- Check your payout status regularly in the Dashboard during the first weeks
- Set up payout.paid and payout.failed webhooks for automated monitoring
- Reconcile payouts with your bank statements weekly
- Use the balance API to forecast cash flow based on available and pending amounts
- Alert your finance team immediately when a payout fails
- Keep your bank account details updated to prevent payout failures
- For Stripe Connect platforms, monitor connected account payouts separately

## Frequently asked questions

### What does 'pending' payout status mean?

Pending means the payout is scheduled but Stripe hasn't sent it to your bank yet. This is normal — payouts sit in pending status until the next scheduled payout time.

### What does 'in_transit' mean?

In transit means Stripe has sent the funds to your bank, but your bank hasn't confirmed receipt yet. This typically lasts 1-2 business days for US accounts.

### How long do payouts take to arrive?

For US accounts, payouts typically arrive in 2 business days after initiation. International accounts may take 3-7 business days depending on the country and bank.

### What causes a payout to fail?

Common causes: incorrect bank account details, closed bank account, bank rejecting the deposit, or account restrictions. Check the failure_message field on the payout object for the specific reason.

### What happens to funds from a failed payout?

Failed payout funds are returned to your Stripe available balance. Stripe may automatically retry the payout, or you can trigger a manual payout after fixing the issue (e.g., updating your bank details).

### How do I reconcile payouts with my bank account?

Each payout has a unique ID and amount. Match these with deposits in your bank statement. Use the Stripe Dashboard export feature or API to download payout details for accounting.

---

Source: https://www.rapidevelopers.com/stripe-guide/how-to-check-pending-payouts-in-stripe
© RapidDev — https://www.rapidevelopers.com/stripe-guide/how-to-check-pending-payouts-in-stripe