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

## Availability

Credential reuse for Global Payouts is in public preview, and is available to eligible users who are using v2 Accounts. Inbound-to-outbound credential reuse isn’t supported for Stripe accounts based in India. This restriction applies to your Stripe account’s country, not your customer’s location, the recipient’s country, or the card’s issuing country.

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

- Inbound-to-outbound credential reuse isn’t supported for Stripe accounts based in India.
- 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

Sandbox secret keys work with the Global Payouts APIs, but full-access secret keys (`sk_live_...`) don’t work in live mode. For live requests, use a [restricted API key](https://docs.stripe.com/keys/restricted-api-keys.md). For a standard integration, [create one in the Dashboard](https://dashboard.stripe.com/apikeys/create) with these permissions:

- `Recipient Configuration: Write`
- `Merchant Configuration: Write`
- `Money Management Financial Accounts: Read`
- `Money Management Payout Methods: Write`
- `Money Management Outbound Payments: Write`
- `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’re 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": {},
        "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/events/set-up-events.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
}
```