# Reuse payment credentials for Global Payouts

Reuse a customer's payment method as a payout method for sending payouts.

If you’ve already collected identity and payment method information from a customer (for example, debit card or bank account details) to accept payments, you can reuse those same details to enable the same account as a payout method for [Global Payouts](https://docs.stripe.com/global-payouts.md), instead of collecting the information again. For example, if you already have payment method information for a customer, you can reuse it to pay out to that customer instead of asking them to submit their details again.

Potential use cases include:

- **Insurance**: Collect an insurance premium from a customer up front, and pay out approved claims later using the same payout details.
- **Prediction market**: Collect a bet from a customer up front, and pay out winnings using the same payout details.

## Availability

Credential reuse for Global Payouts is in public preview, and is available to all users who are using V2 Accounts. You can reuse credentials attached to customer-configured `Account` objects that you create with Accounts v2. You can also enable **Reusable payment methods for Global Payouts** in your [Dashboard](https://dashboard.stripe.com/settings/previews) to project existing `Customer` objects and their eligible `PaymentMethod` objects to v2 `Account` and `PayoutMethod` objects.

Use the latest preview API version compatible with your integration. The earliest supported version of credential reuse is `2026-04-22.preview`.

## Limitations

- You can only reuse credentials for US, EU, and UK debit cards and US bank accounts (ACH direct debit).
- You can’t reuse credentials from cards added through a digital wallet, such as Apple Pay or Google Pay.
- If you [share customers and payment methods across accounts](https://docs.stripe.com/get-started/account/orgs/sharing/customers-payment-methods.md), you can’t reuse payment method credentials collected from one account to create a payout method for a different account in its sharing group.
- You can only reuse credentials for [PaymentMethods](https://docs.stripe.com/api/payment_methods/object.md), not legacy [Cards](https://docs.stripe.com/api/cards.md) or [Sources](https://docs.stripe.com/api/sources.md).

## 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**
- **Merchant 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**.

## How credential reuse works

Use the Accounts v2 API to represent each of your end users with one `Account` object that supports all interactions with them, including both payments and payouts.

When you create an `Account` with the [customer configuration](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer) using the v2 API, Stripe automatically creates a v1 [Customer](https://docs.stripe.com/api/customers/object.md) object (ID prefix `cus_`) alongside the v2 `Account` object (ID prefix `acct_`).

When you opt in to the credential reuse preview feature in [Dashboard Settings](https://dashboard.stripe.com/settings/previews), Stripe enables the Accounts v2 preview and copies each existing `Customer` object to a related v2 `Account` object with the `customer` configuration. You can find the ID of the `Account` object in the `Customer` object’s [customer_account](https://docs.stripe.com/api/customers/object.md#customer_object-customer_account) property.

If you create a `Customer` object after opting in to the credential reuse preview, Stripe automatically creates a corresponding `Account` object with the `customer` configuration. However, we recommend that you create `Account` objects directly. If you create a `Customer`, listen for the [v2.core.account.created](https://docs.stripe.com/api/v2/core/events/event-types.md#v2_event_types-v2.core.account.created) webhook event. An event with a `related_object.id` that matches the [customer_account](https://docs.stripe.com/api/customers/object.md#customer_object-customer_account) property of the `Customer` object indicates that the related `Account` object has been created.

The following `Customer` object properties are related to the corresponding `Account` object properties:

| Customer property | Account property |
| --- | --- |
| [name](https://docs.stripe.com/api/customers/object.md#customer_object-name) | [display_name](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-display_name) |
| [email](https://docs.stripe.com/api/customers/object.md#customer_object-email) | [contact_email](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-contact_email) |
| [address](https://docs.stripe.com/api/customers/object.md#customer_object-address) | - [identity.individual.address](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-identity-individual-address) if the entity type is `individual`
- [identity.business_details.address](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-identity-business_details-address) if the entity type is any type other than `individual` |
| [phone](https://docs.stripe.com/api/customers/object.md#customer_object-phone) | - [identity.individual.phone](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-identity-individual-phone) if the entity type is `individual`
- [identity.business_details.phone](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-identity-business_details-phone) if the entity type is any type other than `individual` |
| [preferred_locales](https://docs.stripe.com/api/customers/object.md#customer_object-preferred_locales) | [defaults.locales](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-defaults-locales) |
| [metadata](https://docs.stripe.com/api/customers/object.md#customer_object-metadata) | [metadata](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-metadata) |
| [shipping](https://docs.stripe.com/api/customers/object.md#customer_object-shipping) | [configuration.customer.shipping](https://docs.stripe.com/api/v2/core/accounts/create.md#v2_create_accounts-configuration-customer-shipping) |
| [business_name](https://docs.stripe.com/api/customers/object.md#customer_object-business_name) | [identity.business_details.registered_name](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-identity-business_details-registered_name) |
| [tax_exempt](https://docs.stripe.com/api/customers/object.md#customer_object-tax_exempt) | [configuration.customer.automatic_indirect_tax.exempt](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer-automatic_indirect_tax) |
| [invoice_prefix](https://docs.stripe.com/api/customers/object.md#customer_object-invoice_prefix) | [configuration.customer.billing.invoice.prefix](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer-billing-invoice-prefix) |

## Create an Account

This workflow assumes that you are directly creating `Account` objects using the Accounts v2 API. Each Account must have the `customer` and `recipient` configurations, which you can set when you create the `Account`. You can also add them later by [updating the Account](https://docs.stripe.com/api/v2/core/accounts/update.md).

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-09-30.preview" \
  --json '{
    "contact_email": "jenny.rosen@example.com",
    "display_name": "Jenny Rosen",
    "identity": {
        "country": "us",
        "entity_type": "individual",
        "individual": {
            "address": {
                "city": "San Francisco",
                "line1": "123 Main St",
                "postal_code": "94105",
                "state": "CA",
                "country": "US"
            },
            "given_name": "Jenny",
            "surname": "Rosen"
        }
    },
    "configuration": {
        "customer": {
            "capabilities": {
                "automatic_indirect_tax": {
                    "requested": true
                }
            }
        },
        "recipient": {
            "capabilities": {
                "bank_accounts": {
                    "local": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.customer",
        "configuration.recipient",
        "identity"
    ]
  }'
```

If you create `Customer` objects instead, [retrieve the Account ID from the Customer’s customer_account property](https://docs.stripe.com/global-payouts/credential-reuse.md#retrieve-existing-ids).

## Optional: Retrieve Account IDs for existing Customer objects

If you have existing `Customer` objects and have opted in to the credential reuse preview feature in Settings, each of your `Customer` objects has a related `Account` object. To get the ID of the `Account` object related to a `Customer` object, [retrieve the Customer](https://docs.stripe.com/api/customers/retrieve.md) and look at the `customer_account` property.

```curl
curl https://api.stripe.com/v1/customers/cus_123 \
  -u "<<YOUR_SECRET_KEY>>:"
```

The `customer_account` property contains the `Account` ID:

```json
{
  "id": "cus_123",
  "object": "customer",
  "customer_account": "acct_123",
  // other customer fields
}
```

## Collect credentials

### Configure webhook notifications

Before you collect payment method information, [set up an event destination](https://docs.stripe.com/event-destinations.md) to receive the [v2.money_management.payout_method.created](https://docs.stripe.com/api/v2/money-management/payout-methods/event-types.md?api-version=preview#v2_payout_methods_event_types-v2.money_management.payout_method.created) event. When receiving webhooks, [verify event signatures](https://docs.stripe.com/webhooks.md#verify-events) and use [Stripe’s public IP address list](https://docs.stripe.com/ips.md).

### Collect payment method information

1. Enable **Cards** and **ACH Direct Debit** in the Dashboard [Payment methods](https://dashboard.stripe.com/settings/payment_methods) page.
2. Use the [Payment Element](https://docs.stripe.com/payments/payment-element.md) or any custom Checkout integration to collect payment method credentials. Create a [SetupIntent](https://docs.stripe.com/api/setup_intents/create.md) or [PaymentIntent](https://docs.stripe.com/api/payment_intents/create.md) and attach it to the `Account` object using the `customer_account` parameter.
3. Use `payment_method_data` to specify information about the bank account or debit card. This example uses `us_bank_account`:

```curl
curl https://api.stripe.com/v1/setup_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -H "Stripe-Version: 2026-09-30.preview" \
  -d confirm=true \
  -d customer_account=acct_123 \
  -d "mandate_data[customer_acceptance][accepted_at]=1678942624" \
  -d "mandate_data[customer_acceptance][type]=offline" \
  -d "payment_method_data[billing_details][address][line1]=123 Main St" \
  -d "payment_method_data[billing_details][address][postal_code]=94105" \
  --data-urlencode "payment_method_data[billing_details][email]=jenny.rosen@example.com" \
  -d "payment_method_data[billing_details][name]=Jenny Rosen" \
  -d "payment_method_data[type]=us_bank_account" \
  -d "payment_method_data[us_bank_account][account_holder_type]=individual" \
  -d "payment_method_data[us_bank_account][account_number]=000123456789" \
  -d "payment_method_data[us_bank_account][routing_number]=110000000" \
  -d "payment_method_options[us_bank_account][verification_method]=automatic" \
  --data-urlencode "return_url=https://www.stripe.com"
```

```json
{
  "id": "seti_123",
  "object": "setup_intent",
  "customer_account": "acct_123",
  "payment_method": "pm_123",
  "payment_method_types": [
    "us_bank_account"
  ],
  // Other SetupIntent fields
  "status": "succeeded"
}
```

Stripe projects the eligible `PaymentMethod` to a `PayoutMethod` asynchronously. The ID starts with a different prefix than `pm_`, depending on the credential type (for example, `usba_` or `card_`).

### Retrieve the new payout method ID

When Stripe finishes projecting the credential, use `related_object.id` from the `v2.money_management.payout_method.created` event as the new `PayoutMethod` ID.

#### Webhooks

Listen for `v2.money_management.payout_method.created`:

```json
{
  "id": "evt_123",
  "object": "v2.core.event",
  "type": "v2.money_management.payout_method.created",
  "created": "2026-04-29T12:00:00+0000",
  "related_object": {
    "id": "usba_test_123", // The new v2 payout method ID
    "type": "v2.money_management.payout_method",
    "url": "/v2/money_management/payout_methods/usba_test_123"
  },
  "changes": null,
  "context": null,
  "data": {},
  "reason": null,
  "livemode": false
}
```

A new `PayoutMethod` isn’t ready for money movement until you [enable](https://docs.stripe.com/global-payouts/credential-reuse.md#enable-the-payout-method) it. Its usage status is initially `disabled` for both payments and transfers:

```json
{
  "id": "usba_test_123",
  "object": "v2.money_management.payout_method",
  "alternative_reference": {
    "id": "pm_123",
    "type": "payment_method"
  },
  "usage_status": {
    "payments": "disabled",
    "transfers": "disabled"
  }
}
```

#### ListPayoutMethods

Alternatively, use [List PayoutMethods](https://docs.stripe.com/api/v2/money-management/payout-methods/list.md?api-version=preview) to find the projected `PayoutMethod`. Set the `Stripe-Context` header to the customer Account ID created in Step 1, then match `alternative_reference.id` to the original `pm_` ID:

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

The response contains the new `PayoutMethod` ID:

```json
{
  "data": [
    {
      "id": "usba_test_123", // The new v2 payout method ID
      "object": "v2.money_management.payout_method",
      "alternative_reference": {
        "id": "pm_123", // The ID of the underlying payment method
        "type": "payment_method"
      },
      "available_payout_speeds": [
        "instant",
        "standard"
      ],
      "bank_account": {
        "archived": false,
        "bank_account_type": "checking",
        "bank_name": "STRIPE TEST BANK",
        "branch_number": null,
        "country": "US",
        "enabled_delivery_options": [
          "local"
        ],
        "financial_connections_account": null,
        "last4": "6789",
        "routing_number": "110000000",
        "supported_currencies": [
          "usd"
        ],
        "swift_code": null
      },
      "created": "2026-04-29T12:00:00+0000",
      "latest_outbound_setup_intent": null,
      "restricted": false,
      "type": "bank_account",
      "usage_status": {
        "payments": "disabled",
        "transfers": "disabled"
      },
      "livemode": false
    }
  ]
}
```

### Enable the payout method

To enable a credential for outbound payments, [create an OutboundSetupIntent](https://docs.stripe.com/api/v2/money-management/outbound-setup-intents/create.md?api-version=preview) with the `PayoutMethod` ID from `related_object.id`. Set the `Stripe-Context` header to the customer 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-09-30.preview" \
  -H "Stripe-Context: {{CONTEXT_ID}}" \
  --json '{
    "payout_method": "usba_test_123",
    "usage_intent": "payment"
  }'
```

[Create an OutboundSetupIntent](https://docs.stripe.com/api/v2/money-management/outbound-setup-intents/create.md?api-version=preview) to complete setup. The OutboundSetupIntent response contains the updated `PayoutMethod`:

```json
{
  "id": "osi_test_123",
  "object": "v2.money_management.outbound_setup_intent",
  "next_action": null,
  "payout_method": {
    "id": "usba_test_123",
    "object": "v2.money_management.payout_method",
    "usage_status": {
      "payments": "eligible",
      "transfers": "eligible"
    }
  },
  "status": "succeeded",
  "usage_intent": "payment"
}
```

## Send the payout to the recipient

### Request Account recipient capabilities

To let an `Account` receive payouts, request Global Payouts capabilities on its `recipient` configuration the same way you would for any [Global Payouts](https://docs.stripe.com/global-payouts.md) recipient, either when you create the `Account` or by updating it later. See [Create a recipient](https://docs.stripe.com/global-payouts/recipient-creation.md#create-recipients-with-no-code) for the Dashboard and API steps, and [Capabilities](https://docs.stripe.com/global-payouts/recipient-creation.md#capabilities) for the full list of capabilities you can request. You can optionally set a [default payout method](https://docs.stripe.com/global-payouts/recipient-creation.md#set-a-default-payout-method-for-a-recipient) for the `Account`, so Stripe knows which method to use for a currency if a payout doesn’t specify one.

```curl
curl -X POST https://api.stripe.com/v2/core/accounts/acct_123 \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-09-30.preview" \
  --json '{
    "configuration": {
        "recipient": {
            "capabilities": {
                "bank_accounts": {
                    "local": {
                        "requested": true
                    }
                }
            }
        }
    },
    "include": [
        "configuration.recipient"
    ]
  }'
```

To confirm that a capability is active, [retrieve the Account and inspect its capability status](https://docs.stripe.com/global-payouts/recipient-creation.md#confirm-recipient-is-enabled). Include `configuration.recipient` in the request, otherwise the property is `null`. The `status` must be `active` for the `Account` to receive payouts by that payout method.

### Send the payout

After the payout method is active, send the payout the same way as for any other Global Payouts recipient. See [Send money](https://docs.stripe.com/global-payouts/send-money.md) for the Dashboard and API steps to retrieve your FinancialAccount ID and send the payout.

## Manage credentials

Any updates made to the underlying v1 `PaymentMethod` get propagated to the related v2 `PayoutMethod` if they’re relevant to the payout method (for example, [detaching a payment method from a customer](https://docs.stripe.com/api/payment_methods/detach.md?api-version=.preview) or [updating a card’s expiration date](https://docs.stripe.com/api/payment_methods/update.md?api-version=preview#update_payment_method-card-exp_year)). When the payout method updates, Stripe emits a `payout_method.updated` webhook event. [Verify the webhook signature](https://docs.stripe.com/webhooks.md#verify-events) before acting on it, to make sure the event came from Stripe.

```curl
curl -X POST https://api.stripe.com/v1/payment_methods/pm_123/detach \
  -u "<<YOUR_SECRET_KEY>>:"
```

```json
{
  "id": "pm_123",
  "object": "payment_method",
  "customer_account": null, // customer_account is null now that it is detached
  "livemode": false,
  "type": "card"
  // other PM fields
}
```

Listen for the `v2.money_management.payout_method.updated` event:

```json
{
  "id": "evt_456",
  "object": "v2.core.event",
  "type": "v2.money_management.payout_method.updated",
  "created": "2026-04-30T12:00:00+0000",
  "related_object": {
    "id": "usba_test_123",
    "type": "v2.money_management.payout_method",
    "url": "/v2/money_management/payout_methods/usba_test_123"
  },
  "changes": {
    "before": {
      "us_bank_account": {
        "archived": false
      }
    },
    "after": {
      "us_bank_account": {
        "archived": true
      }
    }
  },
  "context": null,
  "data": {},
  "reason": null,
  "livemode": false
}
```

Set the `Stripe-Context` header to the customer Account ID when you retrieve the updated `PayoutMethod`.

The updated `PayoutMethod` looks like this:

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

```json
{
  "id": "usba_test_123",
  "object": "v2.money_management.payout_method",
  "alternative_reference": {
    "id": "pm_123",
    "type": "payment_method"
  },
  "bank_account": {
    "archived": true,
    "bank_account_type": "checking",
    "bank_name": "STRIPE TEST BANK",
    "branch_number": null,
    "country": "US",
    "enabled_delivery_options": [
      "local"
    ],
    "financial_connections_account": null,
    "last4": "6789",
    "routing_number": "110000000",
    "supported_currencies": [
      "usd"
    ],
    "swift_code": null
  },
  "created": "2026-04-29T12:00:00+0000",
  "latest_outbound_setup_intent": null,
  "type": "bank_account",
  "usage_status": {
    "payments": "eligible",
    "transfers": "eligible"
  },
  "livemode": false
}
```