# How to resolve Stripe 'payouts not enabled' error

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

## TL;DR

The 'Payouts not enabled' error in Stripe means your account is missing required verification information — typically business details, bank account, or identity documents. This guide walks through every verification requirement, shows how to check your account status via the API, and provides the exact steps to resolve the error and start receiving payouts.

## Understanding the Payouts Not Enabled Error

Stripe requires identity verification, business details, and a valid bank account before enabling payouts. If any of these are missing or outdated, Stripe sets payouts_enabled to false on your account. This commonly happens with new accounts, after regulatory changes, or when Stripe requests additional documentation. The fix is straightforward: identify the missing requirements and submit them.

## Before you start

- A Stripe account (test or live mode)
- Node.js 18 or later installed
- Stripe Node.js SDK installed: npm install stripe
- Access to your Stripe Dashboard

## Step-by-step guide

### 1. Check your account's payouts_enabled status

Use the API to confirm that payouts are disabled and see what requirements are outstanding.

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

async function checkPayoutStatus() {
  const account = await stripe.accounts.retrieve();
  console.log('Payouts enabled:', account.payouts_enabled);
  console.log('Currently due:', account.requirements.currently_due);
  console.log('Past due:', account.requirements.past_due);
  console.log('Errors:', account.requirements.errors);
}

checkPayoutStatus();
```

**Expected result:** Console shows payouts_enabled: false along with arrays listing the missing requirements like 'individual.verification.document' or 'external_account'.

### 2. Submit missing verification information

Based on the requirements listed in currently_due or past_due, update your account. Common requirements include business type, external bank account, and identity verification.

```
async function submitRequirements() {
  // Example: update business profile and individual details
  const account = await stripe.accounts.update('acct_self', {
    business_profile: {
      mcc: '5734',
      url: 'https://yoursite.com',
    },
    individual: {
      first_name: 'Jane',
      last_name: 'Doe',
      dob: { day: 15, month: 6, year: 1990 },
      address: {
        line1: '123 Main St',
        city: 'San Francisco',
        state: 'CA',
        postal_code: '94111',
        country: 'US',
      },
      ssn_last_4: '1234',
    },
  });
  console.log('Updated. Payouts enabled:', account.payouts_enabled);
  console.log('Remaining requirements:', account.requirements.currently_due);
}

submitRequirements();
```

**Expected result:** The requirements list shrinks. If all requirements are met, payouts_enabled flips to true.

### 3. Add an external bank account if missing

Payouts require a linked bank account or debit card. If 'external_account' is in your requirements, add one.

```
async function addBankAccount() {
  const account = await stripe.accounts.createExternalAccount('acct_self', {
    external_account: {
      object: 'bank_account',
      country: 'US',
      currency: 'usd',
      routing_number: '110000000', // Test routing number
      account_number: '000123456789', // Test account number
    },
  });
  console.log('Bank account added:', account.id);
}

addBankAccount();
```

**Expected result:** A bank account object is created and linked to your Stripe account.

### 4. Set up a webhook to monitor verification changes

Listen for account.updated events so you know immediately when payouts become enabled or if new requirements appear.

```
const express = require('express');
const app = express();

app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['stripe-signature'];
  let event;
  try {
    event = stripe.webhooks.constructEvent(
      req.body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET
    );
  } catch (err) {
    console.error('Webhook signature failed:', err.message);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  if (event.type === 'account.updated') {
    const account = event.data.object;
    console.log('Payouts enabled:', account.payouts_enabled);
    console.log('Requirements:', account.requirements.currently_due);
  }

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

app.listen(3000, () => console.log('Webhook listener on port 3000'));
```

**Expected result:** Your server receives account.updated events and logs the current payout status whenever Stripe updates your account.

## Complete code example

File: `fix-payouts-not-enabled.js`

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

async function diagnosePayoutIssue() {
  const account = await stripe.accounts.retrieve();
  console.log('Payouts enabled:', account.payouts_enabled);

  if (!account.payouts_enabled) {
    const reqs = account.requirements;
    console.log('\nCurrently due:', reqs.currently_due);
    console.log('Past due:', reqs.past_due);
    console.log('Pending verification:', reqs.pending_verification);

    if (reqs.errors && reqs.errors.length > 0) {
      console.log('\nErrors:');
      reqs.errors.forEach((e) => {
        console.log(`  - ${e.requirement}: ${e.reason}`);
      });
    }

    if (reqs.currently_due.includes('external_account')) {
      console.log('\nAction needed: Add a bank account or debit card.');
    }
    if (reqs.currently_due.some((r) => r.includes('verification'))) {
      console.log('Action needed: Submit identity verification documents.');
    }
  } else {
    console.log('Payouts are enabled. No action needed.');
  }
}

// Webhook to monitor payout status changes
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['stripe-signature'];
  let event;
  try {
    event = stripe.webhooks.constructEvent(
      req.body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET
    );
  } catch (err) {
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  if (event.type === 'account.updated') {
    const acct = event.data.object;
    if (acct.payouts_enabled) {
      console.log('Payouts are now enabled!');
    } else {
      console.log('Payouts still disabled. Due:', acct.requirements.currently_due);
    }
  }

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

app.listen(3000, () => {
  console.log('Server running on port 3000');
  diagnosePayoutIssue();
});
```

## Common mistakes

- **Ignoring the requirements.errors array** — undefined Fix: The errors array contains specific rejection reasons (e.g., blurry document). Always check it for actionable feedback.
- **Only checking currently_due and missing past_due** — undefined Fix: Requirements in past_due have already passed their deadline and may be causing payouts to be disabled. Address these first.
- **Submitting test documents in live mode** — undefined Fix: Stripe's test tokens only work in test mode. In live mode, submit real documents through the Dashboard or API.
- **Not setting up webhooks to track verification progress** — undefined Fix: Verification can take hours to days. Use account.updated webhooks instead of polling the API.

## Best practices

- Complete all verification requirements during initial account setup to avoid payout interruptions
- Monitor account.updated webhook events for early warning of new requirements
- Keep business information current — address changes or legal name changes can trigger re-verification
- Use the Stripe Dashboard verification checklist for a visual overview of what is missing
- In test mode, use Stripe's test SSN and document tokens to simulate the full verification flow
- Set up alerts when payouts_enabled changes to false so your team can respond quickly
- For platforms using Connect, check each connected account's requirements separately

## Frequently asked questions

### How long does Stripe verification take?

Automated checks complete in minutes. Manual document review can take 1-3 business days. You will receive an account.updated webhook when verification completes.

### Can I still accept payments if payouts are not enabled?

Yes. Stripe can still process charges. The funds accumulate in your Stripe balance and are paid out once payouts are enabled.

### What documents does Stripe require for verification?

Typically a government-issued ID (passport, driver's license) for the individual, and business registration documents for companies. The exact requirements depend on your country and business type.

### Why did my payouts get disabled after being enabled?

Stripe may request additional information due to regulatory changes, increased transaction volume, or periodic re-verification. Check requirements.currently_due for what is newly required.

### Can RapidDev help if my Stripe verification keeps failing?

Yes. RapidDev's engineering team can help troubleshoot complex Stripe account verification issues, especially for platforms using Connect with multiple account types.

---

Source: https://www.rapidevelopers.com/stripe-guide/how-to-resolve-stripe-payouts-not-enabled-error
© RapidDev — https://www.rapidevelopers.com/stripe-guide/how-to-resolve-stripe-payouts-not-enabled-error