# Create recipients

Learn how to create a recipient for your payout.

A recipient is the person or business you’re paying. You need to create a recipient before you can send them a payout. After you create a recipient, you can reuse their information for future payouts.

## Requirement information collection

Stripe offers two ways to collect recipient information

- **Offload recipient collection to Stripe**: Generate a secure, prebuilt hosted form using the Stripe Dashboard or API so recipients can enter their own payout details, letting Stripe handle sensitive bank data and identity verification.
- **Control the recipient flow**: Collect payout and identity information directly within your own UI, then submit the details to Stripe using the Dashboard or API.

Requirements vary. See [recipient requirements](https://docs.stripe.com/global-payouts/recipient-requirements.md) for the full list of supported countries and requirements, by business type and payout method.

|  | No code | Stripe-hosted | Code required |
| --- | --- | --- | --- |
| **Branding and localization** | Not applicable | Co-branded with your business name, logo, and colors, and automatically localized | Full control over the UI, but no automatic localization |
| **Automatic updates for new compliance requirements** | Requires you to provide more information | Immediate | Requires integration changes |
| **Supports new countries without changes** | ✓ Supported | ✓ Supported | ❌ |
| **Flow logic** | Not applicable | Limited control | Full control |

## Create a recipient 

#### Dashboard

You can create recipients without using code in a few ways through the Stripe Dashboard.

1. Go to **Treasury** > **Payouts** > [Recipients](https://dashboard.stripe.com/global-payouts/recipients), then click **Add recipient**.
2. Enter the recipient’s email and country. You can also add a name to access the recipient later.
3. Choose how you want to collect the recipient’s information: Stripe can email the recipient a link to a Stripe-hosted form (**Pay via Email**), you can send that link to the recipient directly, or you can enter their information yourself. See [recipient requirements](https://docs.stripe.com/global-payouts/recipient-requirements.md) for the information you need to collect.
4. (Optional) Update the payout methods you want to enable for the recipient. After the recipient is created, you can also update payout methods from **Recipient details** > **Payout methods**.
5. Complete the flow by either clicking **Continue** or **Send email** (if you elected for Stripe to send the email directly).

The link is valid for 3 days, until it’s clicked twice or completed.

For compliance reasons, you can’t enter a recipient’s debit card information manually. This recipient creation method supports only bank accounts and crypto wallets.

> #### Pay via Email considerations
> 
> - Pay via Email doesn’t support cross-border payouts. The sender and recipient must be in the same country.
> - Pay via Email isn’t available in the EU due to [Verification of Payee regulation](https://support.stripe.com/questions/verification-of-payee-support-for-financial-accounts).

#### Stripe-hosted

Use the [Account Links API](https://docs.stripe.com/api/v2/core/account-links.md) to programmatically generate links to collect information with Stripe-hosted forms, which renders dynamically based on the capabilities, country, and payout methods for each recipient. You can also customize with your business name, brand colors, and icon. Your recipients complete the hosted form and submit required details, including payout method details (for example, bank account and routing number) directly to Stripe.
![Recipient enters their information in the form](https://b.stripecdn.com/docs-statics-srv/assets/stripe-hosted1.b2a794696c10dcecdced4869e1d94e56.png)

The recipient enters their information in the Stripe-hosted form.
![Recipient agrees to connect their payout credentials to Stripe](https://b.stripecdn.com/docs-statics-srv/assets/stripe-hosted2.ae2c0c01b188e67f8a3c5b720dc8e08c.png)

The recipient agrees to connect their payout credentials to Stripe.
![A success screen shows the recipient that they're ready to receive payouts](https://b.stripecdn.com/docs-statics-srv/assets/stripe-hosted4.83fd75e3fbf54e8b81c8a7740a80732e.png)

A success screen shows the recipient that they’re ready to receive payouts.

### Supported browsers

Stripe-hosted collection supports desktop and mobile browsers that are:

- The last 20 major versions of Chrome and Firefox
- The last two major versions of Safari and Edge
- The last two major versions of mobile Safari on iOS
- Not iframe environments

### Customize the collection form

To customize Stripe-hosted forms, go to the [Business brand settings page](https://dashboard.stripe.com/settings/branding) in the Dashboard to include your business name, color, and icon.

### Create the recipient with the API

To create a recipient, provide their details and specify which payout methods to enable.

Use the [Accounts v2 API](https://docs.stripe.com/api/v2/core/accounts/create.md) to create your recipient. You must specify your intended payout methods because some methods require additional recipient information before you can enable them. The methods you enable with the `capabilities` parameter determine the KYC information you need to collect for your recipient, such as their name and date of birth.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  --json '{
    "contact_email": "jenny.rosen@example.com",
    "display_name": "Jenny Rosen",
    "identity": {
        "country": "us",
        "entity_type": "individual"
    },
    "configuration": {
        "recipient": {
            "capabilities": {
                "bank_accounts": {
                    "local": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "requirements",
        "configuration.recipient",
        "identity"
    ]
  }'
```

When you request capabilities, the API response includes the additional information required to activate them in the [requirements.entries](https://docs.stripe.com/api/v2/core/accounts/create.md#v2_create_accounts-response-requirements-entries) array.

### Capabilities

#### OutboundPayments capabilities

The following table shows the capability hashes for recipient banking rails. To request a capability, set the `requested` parameter in its hash to `true`.

| Banking rail | Capability hash | Description |
| --- | --- | --- |
| Local | `configuration.recipient.capabilities.bank_accounts.local` | Allows the `Account` to receive `OutboundPayments` over local bank networks, such as ACH or FPS. |
| Bank wire | `configuration.recipient.capabilities.bank_accounts.wire` | Allows the `Account` to receive `OutboundPayments` over wire networks, such as Fedwire or SWIFT. |
| Cards | `configuration.recipient.capabilities.cards` | Allows the `Account` to receive `OutboundPayments` over debit card networks, such as Visa Direct or Mastercard Send. |

#### PayoutIntents capabilities (Private preview)

If you use PayoutIntents, the following capability hashes are available instead:

| Banking rail | Capability hash | Description |
| --- | --- | --- |
| ACH (US domestic) | `configuration.recipient.capabilities.bank_accounts.ach` | Allows the `Account` to receive payouts over the ACH network. |
| Fedwire (US wire) | `configuration.recipient.capabilities.bank_accounts.fedwire` | Allows the `Account` to receive payouts over the Fedwire network. |
| FPS (UK domestic) | `configuration.recipient.capabilities.bank_accounts.fps` | Allows the `Account` to receive payouts over the Faster Payments Service. |
| SEPA (Eurozone) | `configuration.recipient.capabilities.bank_accounts.sepa` | Allows the `Account` to receive payouts over the SEPA Credit Transfer network. |
| SEPA Instant (Eurozone) | `configuration.recipient.capabilities.bank_accounts.sepa_instant` | Allows the `Account` to receive payouts over the SEPA Instant Credit Transfer network. |
| Local (cross-border) | `configuration.recipient.capabilities.bank_accounts.local` | Allows the `Account` to receive cross-border payouts over local bank networks. |
| SWIFT (cross-border wire) | `configuration.recipient.capabilities.bank_accounts.swift` | Allows the `Account` to receive cross-border payouts over the SWIFT network. |
| Cards | `configuration.recipient.capabilities.cards` | Allows the `Account` to receive payouts over debit card networks, such as Visa Direct or Mastercard Send. |

A recipient can have multiple payout methods of different types. Which payout methods are available depends on the recipient’s country. See the full list of [available payout methods by country](https://docs.stripe.com/global-payouts/recipient-requirements.md#requirements).

After you add these fields and requested payout methods, Stripe determines the additional information required in the API response that you need to submit to make the recipient ready to receive payouts.

### Create a shareable link

Create a shareable link using the [Account Link API](https://docs.stripe.com/api/v2/core/account-links/create.md). You send this link to your recipient, who then has access to the collection form to submit required information directly to Stripe. Each `AccountLink` URL expires 10 minutes after generation and can be used only once. If your recipient clicks the `AccountLink` after the 10 minute window, they’re redirected to the `refresh_url` for security reasons. After your recipient provides their information, the `AccountLink` redirects to the `return_url`.

> Interested in verifying your recipients? After recipients share their payout method details in Stripe-hosted forms, use the [Financial Connections API](https://docs.stripe.com/financial-connections/ownership.md) to view and confirm the ownership details associated with the linked account. If you’re interested in getting access, [enter your email](https://docs.stripe.com/global-payouts/recipient-creation.md#financial_connections_payouts_preview).

### Interested in verifying your recipients?

Enter your email to request access.

```bash
curl https://docs.stripe.com/preview/register \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Referer: https://docs.stripe.com/global-payouts/recipient-creation" \
  -d '{"email": "EMAIL", "preview": "financial_connections_payouts_preview"}'
```

To create a shareable link, include the following parameters:

- `account`: The recipient’s account ID, which you can get using the [Accounts v2 API](https://docs.stripe.com/api/v2/core/accounts.md)
- `use_case.type`: If you’re collecting the recipient’s information for the first time, specify `account_onboarding`.
- `use_case.account_onboarding.configurations`: Set to `recipient`.
- `use_case.account_onboarding.return_url`: The page Stripe redirects the recipient to when they complete or leave the information collection form.
- `use_case.account_onboarding.refresh_url`: The page Stripe redirects the recipient to when the `AccountLink` has already been visited, has expired, or is otherwise invalid.

The following request creates an `AccountLink` for purposes of collecting a recipient’s information for the first time:

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  --json '{
    "account": "{{ACCOUNT_ID}}",
    "use_case": {
        "type": "account_onboarding",
        "account_onboarding": {
            "configurations": [
                "recipient"
            ],
            "return_url": "https://example.com/return",
            "refresh_url": "https://example.com/reauth"
        }
    }
  }'
```

Authenticate the recipient in your application before redirecting them to this URL.

> Interested in additional authentication tools? Stripe also offers a one-time passcode feature to reauthenticate your recipient by sending an authentication code to their email, and then redirecting them to a new `AccountLink`. If you’re interested in getting access, [enter your email](https://docs.stripe.com/global-payouts/recipient-creation.md#authentication_tools_payouts_preview).

### Interested in additional authentication tools?

Enter your email to request access.

```bash
curl https://docs.stripe.com/preview/register \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Referer: https://docs.stripe.com/global-payouts/recipient-creation" \
  -d '{"email": "EMAIL", "preview": "authentication_tools_payouts_preview"}'
```

### Confirmation of Payee check (UK only)

We require a [Confirmation of Payee](https://www.wearepay.uk/what-we-do/overlay-services/confirmation-of-payee/) check before paying UK recipients. Perform this check when you create the bank account, or use a separate API call.

Provide the following parameters in your request to `/v2/payment_methods/gb_bank_accounts`:

| API parameter | Required | Description |
| --- | --- | --- |
| `account_number` | Yes | The bank account’s account number. |
| `sort_code` | Yes | The bank account’s sort code (numeric only). |
| `confirmation_of_payee` | No | Determines whether to check your recipient’s bank account. |

The Stripe-Context header in these requests must be the recipient’s `Account` ID.

```curl
curl -X POST https://api.stripe.com/v2/core/vault/gb_bank_accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  -H "Stripe-Context: {{CONTEXT_ID}}" \
  --json '{
    "sort_code": "108800",
    "account_number": "00012345",
    "confirmation_of_payee": {
        "initiate": true
    }
  }'
```

The following is an example response:

```json
{
  "id": "gbba_123",
  "object": "payment_methods.gb_bank_account",
  "bank_account_type": "checking",
  "bank_name": "Test Bank",
  "created": "2023-05-15T16:29:15.738Z",
  "deactivated": false,
  "last4": "2345",
  "sort_code": "108800",
  "confirmation_of_payee": {
    "result": {
      "created": "2024-10-18T19:19:31.000Z",
      "match_result": "mismatch",
      "matched": {
        "business_type": null,
        "name": ""
      },
      "message": "The provided information does not match the information the bank has on file for this account.",
      "provided": {
        "business_type": "business",
        "name": "John Smith"
      }
    },
    "status": "awaiting_acknowledgement"
  },
}
```

If the Confirmation of Payee result is a match, you can immediately send funds to this destination. If the result is a partial match, non-match, or the service is unavailable, you must acknowledge the result first:

```curl
curl -X POST https://api.stripe.com/v2/core/vault/gb_bank_accounts/gbba_1234/acknowledge_confirmation_of_payee \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  -H "Stripe-Context: {{CONTEXT_ID}}"
```

Review these bank accounts to make sure they’re correct before acknowledging. You can also review non-matching bank accounts in the Dashboard.

### Confirm recipient is enabled

For a recipient to receive payouts, you must collect information about the recipient and the intended payout methods.

After a recipient accesses the collection form from the shareable link and submits the required information, the [v2.core.account_link.returned](https://docs.stripe.com/api/v2/core/events/event-types.md?api-version=2025-07-30.preview&rds=1#v2_event_types-v2.core.account_link.returned) webhook is triggered. Listening to this webhook event lets you know when the recipient has finished submitting their information, but the requested capabilities can still be verifying asynchronously. Check the capability `status` before considering the recipient ready to receive payouts. Learn more about [webhooks and how to handle them](https://docs.stripe.com/webhooks.md).

Alternatively, you can also determine if a recipient is ready to receive payouts using the Dashboard or the [Accounts v2 API](https://docs.stripe.com/api/v2/core/accounts.md).

#### Dashboard

1. Go to [Recipients](https://dashboard.stripe.com/global-payouts/recipients) and select the recipient.
2. Confirm that no additional information is required. A banner on the page displays if we require additional information from the recipient (for example, “Information needed” or “Default bank account not set”). Otherwise, the recipient’s information collection is complete.
3. Confirm that at least one payout method is enabled under Payout Methods. If not, you need to collect a payout method either by sharing another link or using the API. To create another shareable link, use the [Account Links API](https://docs.stripe.com/api/v2/core/account-links.md) again.

#### API

[Retrieve the Account](https://docs.stripe.com/api/v2/core/accounts/retrieve.md) and inspect the `status` of the [capabilities](https://docs.stripe.com/global-payouts/recipient-creation.md#capabilities) you’ve requested. A capability’s `status` must be `active` for the recipient to be eligible to receive payouts by that payout method type. You must also confirm that a specific payout method of that type (for example, a bank account) is attached to the `Account` before you send funds to it.

```curl
curl -G https://api.stripe.com/v2/core/accounts/acct_1234 \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  -d "include[0]=identity" \
  -d "include[1]=configuration.recipient" \
  -d "include[2]=default"
```

### Make updates to an existing recipient

You can allow recipients to update their information in the Stripe-hosted form by creating another shareable link with the [Account Links API](https://docs.stripe.com/api/v2/core/account-links.md).

To create a new shareable link, include:

- `account`: The recipient’s account ID, which you can get using the [Accounts v2 API](https://docs.stripe.com/api/v2/core/accounts.md)
- `use_case.type`: Specify `account_update`.
- `use_case.account_update.configurations`: Set to `recipient`.
- `use_case.account_update.return_url`: The page Stripe redirects the recipient to when they have completed or left the information collection form.
- `use_case.account_update.refresh_url`: The page Stripe redirects the recipient to after the `AccountLink` has already been visited, has expired, or is otherwise invalid.

```curl
curl -X POST https://api.stripe.com/v2/core/account_links \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  --json '{
    "account": "{{ACCOUNT_ID}}",
    "use_case": {
        "type": "account_update",
        "account_update": {
            "configurations": [
                "recipient"
            ],
            "return_url": "https://example.com/return",
            "refresh_url": "https://example.com/reauth"
        }
    }
  }'
```

Similar to the `AccountLink` you use to create the recipient, the URL expires after 10 minutes and you can use it only once. If your recipient opens the URL after 10 minutes or more than once, Stripe redirects them to the `refresh_url`.

#### API

Build an information collection flow for your recipients to collect recipient and payout method details, and then pass that information to Stripe through our APIs.

A recipient is a v2 [Account](https://docs.stripe.com/api/v2/core/accounts.md) configured with recipient capabilities. The API refers to recipients as `Account` objects throughout.

### Use API keys

You must use [restricted API keys](https://docs.stripe.com/keys/restricted-api-keys.md) to make live requests to the Global Payouts APIs. For a standard integration, [create a restricted key with the following permissions](https://dashboard.stripe.com/apikeys/create):

- **Recipient Configuration: Write**
- **Money Management Financial Accounts: Read**
- **Money Management Payout Methods: Write**
- **Money Management Outbound Payments: Write**

Grant additional permissions for these scenarios:

- For UK Confirmation of Payee or SEPA/Eurozone payments that require Recipient Verifications, grant **Money Management Recipient Verifications: Write**.
- If you use the gated Payout Intents API path, grant **Money Management Payout Intents: Write**.

### Create the recipient

When using a form to collect payout recipient information, use the [Accounts API](https://docs.stripe.com/api/v2/core/accounts/create.md?api-version=preview) to create a recipient. You must provide the following parameters to create the `Account`:

| Required information | Parameter |
| --- | --- |
| Recipient’s country | `identity.country` |
| Recipient’s type of business | `identity.entity_type` |
| Recipient’s email | `contact_email` |
| The display name for the `Account`. It appears in the Stripe Dashboard and on any invoices that you send to the `Account`. | `display_name` |
| Capabilities you want to enable | `configuration.recipient.capabilities` |

You must specify your intended payout method types by [requesting the corresponding capabilities](https://docs.stripe.com/connect/account-capabilities.md?accounts-namespace=v2) when you [create the Account](https://docs.stripe.com/api/v2/core/accounts/create.md?api-version=preview#v2_create_accounts-configuration-recipient-capabilities).

| Payout method | API parameter | Description |
| --- | --- | --- |
| Local | `configuration.recipient.capabilities.bank_accounts.local` | Allows the `Account` to receive `OutboundPayments` over local bank networks, such as ACH or FPS. |
| Bank wire | `configuration.recipient.capabilities.bank_accounts.wire` | Allows the `Account` to receive `OutboundPayments` over wire networks, such as Fedwire or SWIFT. |
| Cards | `configuration.recipient.capabilities.cards` | Allows the `Account` to receive `OutboundPayments` over debit card networks, such as Visa Direct or Mastercard Send. |

### Payout concepts for PayoutIntents (Private preview)

If you use PayoutIntents, you work with more granular capabilities based on the following concepts:

- **Payout method**: The type of destination for a payout, such as a bank account, debit card, or crypto wallet.
- **Banking rail**: For bank account payout methods, the specific payment network used to move money (for example, ACH, FPS, or SEPA). A single bank account payout method can support multiple rails.
- **Capability**: A setting on a recipient account that enables a specific payout method or rail. Requesting a capability (for example, `bank_accounts.ach`) begins onboarding for that method. The capability must become `active`, and the recipient must have a corresponding payout method, before you can send payouts using it. Cards and crypto wallets each have a single capability; bank accounts have one capability per supported rail.

#### Bank accounts

| Banking rail | Capability | Description |
| --- | --- | --- |
| ACH (US) | `configuration.recipient.capabilities.bank_accounts.ach` | Allows the `Account` to receive payouts over the ACH network. |
| Fedwire (US wire) | `configuration.recipient.capabilities.bank_accounts.fedwire` | Allows the `Account` to receive payouts over the Fedwire network. |
| RTP (US real-time) | `configuration.recipient.capabilities.bank_accounts.rtp` | Allows the `Account` to receive payouts over the RTP network. |
| FPS (UK) | `configuration.recipient.capabilities.bank_accounts.fps` | Allows the `Account` to receive payouts over the Faster Payments Service. |
| SEPA (Eurozone) | `configuration.recipient.capabilities.bank_accounts.sepa` | Allows the `Account` to receive payouts over the SEPA Credit Transfer network. |
| SEPA Instant (Eurozone) | `configuration.recipient.capabilities.bank_accounts.sepa_instant` | Allows the `Account` to receive payouts over the SEPA Instant Credit Transfer network. |
| Local (cross-border) | `configuration.recipient.capabilities.bank_accounts.local` | Allows the `Account` to receive cross-border payouts over local bank networks. |
| SWIFT (cross-border wire) | `configuration.recipient.capabilities.bank_accounts.swift` | Allows the `Account` to receive cross-border payouts over the SWIFT network. |

#### Other payout methods

| Payout method | Capability | Description |
| --- | --- | --- |
| Debit card | `configuration.recipient.capabilities.cards` | Allows the `Account` to receive payouts over debit card networks, such as Visa Direct or Mastercard Send. |

A recipient can have multiple payout methods of different types. Which payout method types are available depends on the recipient’s country. See the full list of [available payout methods by country](https://docs.stripe.com/global-payouts/recipient-requirements.md#requirements).

Some capabilities require additional KYC information about your recipient, such as their name and date of birth. After you request capabilities, Stripe determines the information requirements that you need to submit to enable them and can identify it in the API response. To receive the requirements in the response, include `requirements`, `configuration.recipient`, and `identity` in the `include` array. Otherwise, Stripe returns a null response for those properties, regardless of their actual values.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  --json '{
    "contact_email": "jenny.rosen@example.com",
    "display_name": "Jenny Rosen",
    "identity": {
        "country": "us",
        "entity_type": "individual"
    },
    "configuration": {
        "recipient": {
            "capabilities": {
                "bank_accounts": {
                    "local": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "identity",
        "configuration.recipient",
        "requirements"
    ]
  }'
```

If you use PayoutIntents (private preview), request the more granular capability for the rail you want instead, such as `bank_accounts.ach`:

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  --json '{
    "contact_email": "jenny.rosen@example.com",
    "display_name": "Jenny Rosen",
    "identity": {
        "country": "us",
        "entity_type": "individual"
    },
    "configuration": {
        "recipient": {
            "capabilities": {
                "bank_accounts": {
                    "ach": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "identity",
        "configuration.recipient",
        "requirements"
    ]
  }'
```

### Determine required fields to activate a recipient

To identify the specific requirements that you must submit, inspect the [requirements.entries](https://docs.stripe.com/api/v2/core/accounts/create.md?api-version=preview#v2_create_accounts-response-requirements-entries) array in the Accounts API response. For the recipient to receive payouts, you must provide all requirements that have the `restricts_capabilities` property.

```json
{
 "id": "{{CONNECTED_ACCOUNT_ID}}",
 "object": "v2.core.account",
 "applied_configurations": [
   "recipient"
 ],
 "configuration": {
   "customer": null,
   "merchant": null,
   "recipient": {
     "capabilities": {
       "bank_accounts": {
         "local": {
           "requested": true,
           "status": "restricted",
           "status_details": [
             {
               "code": "requirements_past_due",
               "resolution": "provide_info"
             }
           ]
         },
         "wire": null,
         "instant": null
       },
       "cards": null,
       "stripe_balance": null
     },
     "default_outbound_destination": null
   }
 },
 "contact_email": "jenny.rosen@stripe.com",
 "created": "2025-04-02T17:20:00.000Z",
 "dashboard": null,
 "identity": {
   "attestations": {
     "directorship_declaration": null,
     "ownership_declaration": null,
     "persons_provided": {
       "directors": null,
       "executives": null,
       "owners": null,
       "ownership_exemption_reason": null
     },
     "terms_of_service": {
       "account": null
     }
   },
   "business_details": null,
   "country": "US",
   "entity_type": "individual",
   "individual": null
 },
 "defaults": null,
 "display_name": "Jenny Rosen",
 "metadata": {},
 "requirements": {
   "collector": "stripe",
   "entries": [
     {
       "awaiting_action_from": "user",
       "description": "identity.individual.given_name",
       "errors": [],
       "impact": {
         "restricts_capabilities": [
           {
             "capability": "bank_accounts.local",
             "configuration": "recipient",
             "deadline": {
               "status": "past_due"
             }
           }
         ],
         "restricts_payouts": null
       },
       "minimum_deadline": {
         "status": "past_due"
       },
       "reference": null,
       "requested_reasons": [
         {
           "code": "routine_onboarding"
         }
       ]
     },
     {
       "awaiting_action_from": "user",
       "description": "identity.individual.surname",
       "errors": [],
       "impact": {
         "restricts_capabilities": [
           {
             "capability": "bank_accounts.local",
             "configuration": "recipient",
             "deadline": {
               "status": "past_due"
             }
           }
         ],
         "restricts_payouts": null
       },
       "minimum_deadline": {
         "status": "past_due"
       },
       "reference": null,
       "requested_reasons": [
         {
           "code": "routine_onboarding"
         }
       ]
     }
   ],
   "summary": {
     "minimum_deadline": {
       "status": "past_due",
       "time": null
     }
   }
 }
}
```

### Submit recipient information to Stripe

After you collect the required information, use the [Accounts API](https://docs.stripe.com/api/v2/core/accounts/update.md?api-version=preview) to submit it.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{CONNECTEDACCOUNT_ID}} \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  --json '{
    "contact_email": "jenny.rosen@example.com",
    "display_name": "Jenny Rosen",
    "identity": {
        "country": "us",
        "entity_type": "individual",
        "individual": {
            "given_name": "Jenny",
            "surname": "Rosen",
            "address": {
                "city": "Brothers",
                "country": "US",
                "line1": "27 Fredrick Ave",
                "postal_code": "97712",
                "state": "OR"
            }
        }
    },
    "include": [
        "identity"
    ]
  }'
```

### Confirm that the recipient is enabled

[Retrieve the Account](https://docs.stripe.com/api/v2/core/accounts/retrieve.md?api-version=preview) and inspect the `status` of the capabilities you’ve requested. The `status` of a capability must be `active` for the recipient to receive payouts by that method.

```curl
curl -G https://api.stripe.com/v2/core/accounts/{{CONNECTEDACCOUNT_ID}} \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  -d "include[0]=configuration.recipient"
```

### Create payout methods for your recipients

After enabling a capability, use the [Outbound Setup Intents API](https://docs.stripe.com/api/v2/money-management/outbound-setup-intents/create.md?api-version=preview) to create the recipient’s actual `PayoutMethod`.

The Stripe-Context header in this request must be the recipient’s `Account` ID.

```curl
curl -X POST https://api.stripe.com/v2/money_management/outbound_setup_intents \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  -H "Stripe-Context: {{CONTEXT_ID}}" \
  --json '{
    "payout_method_data": {
        "type": "bank_account",
        "bank_account": {
            "country": "FR",
            "account_number": "FR76300060000112345678901234"
        }
    }
  }'
```

> The `OutboundSetupIntent` response contains the [PayoutMethod](https://docs.stripe.com/api/v2/money-management/outbound-setup-intents/create.md?api-version=preview#v2_create_outbound_setup_intents-response-payout_method). When making an `OutboundPayment`, use the `PayoutMethod` ID (for example, `frba_test_...`), not the `OutboundSetupIntent` ID (`osi_test_...`).

To send payouts by wire transfer, use the [US Bank Accounts API](https://docs.stripe.com/api/v2/core/vault/us-bank-accounts/update.md?api-version=preview) to add the `fedwire_routing_number` to the `PayoutMethod`. Additional fees apply. See [pricing](https://docs.stripe.com/global-payouts/pricing.md) for details.

You can also use debit cards as a payout method. However, your recipients must submit their debit card information directly to Stripe. If you’re interested in enabling payouts by debit cards, use the [Account Links API](https://docs.stripe.com/api/v2/core/account-links.md) to create a shareable form for your user to submit their debit card credentials. See [Stripe-hosted](https://docs.stripe.com/global-payouts/recipient-creation.md?create-recipient-method=stripe-hosted#create-recipients-with-no-code) for the full walkthrough of this collection flow.

### View all payout methods for a recipient

Use the Payout Methods API to [retrieve a recipient’s PayoutMethods](https://docs.stripe.com/api/v2/money-management/payout-methods/list.md?api-version=preview).

The Stripe-Context header in this request must be the recipient’s `Account` ID.

```curl
curl https://api.stripe.com/v2/money_management/payout_methods \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  -H "Stripe-Context: {{CONTEXT_ID}}"
```

The response contains a list of `PayoutMethod` objects associated with the recipient. Use a `PayoutMethod` ID to make a payout using the [Outbound Payments API](https://docs.stripe.com/api/v2/money-management/outbound-payments/create.md?api-version=preview), or the [Payout Intents API](https://docs.stripe.com/api/v2/money-management/payout-intents/create.md?api-version=preview) (private preview). See [Send money](https://docs.stripe.com/global-payouts/send-money.md) for more details.

### Set a default payout method for a recipient

You can optionally set a recipient’s default payout method for one or more currencies. Stripe uses the default payout method for a currency if you create a payout in that currency without specifying a `PayoutMethod`.

Update the recipient `Account` by adding one or more payout methods to its [defaults.payout_methods](https://docs.stripe.com/api/v2/core/accounts/update.md?api-version=preview#v2_update_accounts-defaults-payout_methods). This property is a map keyed by lowercase ISO currency code, where each value is a `PayoutMethod` ID owned by the recipient.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/{{CONNECTEDACCOUNT_ID}} \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-08-26.preview" \
  --json '{
    "defaults": {
        "payout_methods": {
            "usd": "usba_test_..."
        }
    },
    "include": [
        "defaults"
    ]
  }'
```

The response returns the updated `Account` with the default payout method set for each currency you provided.

```json
{
  "id": "{{CONNECTED_ACCOUNT_ID}}",
  "object": "v2.core.account",
  "defaults": {
    "payout_methods": {
      "usd": "usba_test_..."
    }
  }
  . . .
}
```

If you create a payout in a currency that has a corresponding recipient default set, you don’t need to specify a `PayoutMethod` in the payout request. If you do specify a `PayoutMethod`, it overrides the recipient’s default.

## Considerations

Your business is responsible for all interactions with your recipients and for collecting all the necessary information to verify them. Stripe updates recipient verification requirements as laws and regulations change around the world.

Plan to review and update onboarding requirements on a regular basis to avoid payout failures.