## Confirm a SetupIntent by payment method

Below are a number of methods used to confirm a SetupIntent for a specific payment method type.

## Confirm card setup

Use `stripe.confirmCardSetup` in the [Setup Intents API flow](/payments/save-and-reuse.md) when the customer submits your payment form.
When called, it will confirm the [SetupIntent](/api/setup_intents.md) with `data` you provide and carry out 3DS or other next actions if they are required.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmCardSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.
> 
> Additionally, `stripe.confirmCardSetup` may trigger a [3D Secure](/payments/3d-secure.md) authentication challenge.
> This will be shown in a modal dialog and may be confusing for customers using assistive technologies like screen readers.
> You should make your form accessible by ensuring that success or error messages are clearly read out after this method completes.

`stripe.confirmCardSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmCardSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (string | object)
    Either the `id` of an existing [PaymentMethod](/api/payment_methods.md), or an object containing data to create a `PaymentMethod` with.
See the use case sections below for details.

  - `return_url` (string)
    If you are [handling next actions yourself](/payments/payment-intents/verifying-status.md#next-actions), pass in a `return_url`.
If the subsequent action is `redirect_to_url`, this URL will be used on the return path for the redirect.

- `options` (object)
  An options object to control the behavior of this method.

  - `handleActions` (boolean)
    Set this to `false` if you want to [handle next actions yourself](/payments/payment-intents/verifying-status.md#next-actions), or if you want to defer next action handling until later (e.g. for use in the [PaymentRequest API](/stripe-js/elements/payment-request-button.md#complete-payment-intents)).
Default is `true`.

### Use case: with payment data from an Element

Use `stripe.confirmCardSetup` with payment data from an [Element](/js/element.md) by passing a `card` or `cardNumber` `Element` to `payment_method[card]`.
The new `PaymentMethod` will be created with data collected by the `Element` and will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using data collected by a `card` or `cardNumber` [Element](/js/element.md).

  - `card` (Element) **required**
    Uses the provided `card` or `cardNumber` [Element](/js/element.md) for confirmation.

  - `billing_details` (object)
    The [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details) associated with the card.

### Confirm with an Element

```js
stripe
  .confirmCardSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      card: cardElement,
      billing_details: {
        name: 'Jenny Rosen',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmCardSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      card: cardElement,
      billing_details: {
        name: 'Jenny Rosen',
      },
    },
  },
);
```

### Use case: with an existing payment method

Use `stripe.confirmCardSetup` with an existing `PaymentMethod` by passing its `id` to `payment_method`.
The `PaymentMethod` will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing [PaymentMethod](/api/payment_methods.md).

### Confirm with existing payment method

```js
stripe
  .confirmCardSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmCardSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Use case: with an existing token

For backwards compatibility, you can convert an existing `Token` into a `PaymentMethod` with `stripe.confirmCardSetup` by passing the `Token` to `payment_method[card][token]`.
The newly created `PaymentMethod` will be used to confirm the `PaymentMethod`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using an existing token.

  - `card` (object) **required**
    An object of card data.

    - `token` (string) **required**
      Converts the provided token into a `PaymentMethod` to use for confirmation.

  - `billing_details` (object)
    The [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details) associated with the card.

### Confirm with existing token

```js
stripe
  .confirmCardSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      card: {
        token: 'tok_visa',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmCardSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      card: {
        token: 'tok_visa',
      },
    },
  },
);
```

### Use case: with an attached PaymentMethod

If you have already attached a `PaymentMethod` to this `SetupIntent`, then you can confirm the `SetupIntent` using `stripe.confirmCardSetup` without passing in any additional data.

### Confirm with an attached PaymentMethod

```js
stripe
  .confirmCardSetup('{SETUP_INTENT_CLIENT_SECRET}')
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmCardSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
);
```

### Confirm card setup

```js
stripe
  .confirmCardSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      card: cardElement,
      billing_details: {
        name: 'Jenny Rosen',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmCardSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      card: cardElement,
      billing_details: {
        name: 'Jenny Rosen',
      },
    },
  },
);
```

## Confirm an ACH Direct Debit setup

Use `stripe.confirmUsBankAccountSetup` in the [Save bank details](/payments/ach-direct-debit/set-up-payment.md) flow for the [ACH Direct Debit](/payments/ach-direct-debit.md) payment method to record the customer’s authorization for future payments.

When you confirm a [SetupIntent](/api/setup_intents.md), it needs to have an attached [PaymentMethod](/api/payment_methods.md).
We suggest using `stripe.collectBankAccountForSetup`, which automatically collects bank account details and attaches a [PaymentMethod](/api/payment_methods.md). You may also choose to reuse an existing `PaymentMethod` or manually collect bank account details  using the `data` parameter. These use cases are detailed in the sections that follow.

`stripe.confirmUsBankAccountSetup` will return a `Promise` which resolves with a result object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api#errors) and our [integration guide](/payments/ach-direct-debit/set-up-payment) for all possible errors.

**Syntax:** `stripe.confirmUsBankAccountSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

### Use case: with an existing PaymentMethod

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmUsBankAccountSetup`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing [PaymentMethod](/api/payment_methods.md).

### Confirm with an existing PaymentMethod

```js
stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Use case: with an attached PaymentMethod

If you have successfully called `stripe.collectBankAccountForSetup` or attached a `PaymentMethod` to this `SetupIntent` already, then you can confirm the `SetupIntent` without passing in any additional data.

### Confirm with an attached PaymentMethod

```js
stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {}
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {}
);
if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Use case: with self collected bank account information

If you already know the customer’s bank account information, or want to collect it yourself, you can pass them in directly to create a new `PaymentMethod` and confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using data collected.

  - `billing_details` (Object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` is required. Providing `email` allows your customer to receive [ACH Direct Debit mandate and microdeposit emails](/payments/ach-direct-debit.md#mandate-and-microdeposit-emails).

    - `name` (string) **required**
      The customer's name. The first and last name must be at minimum 2 characters each.

    - `email` (string)
      The customer's email.

  - `us_bank_account` (Object) **required**
    The customer's [bank account information](/api/payment_methods/create.md#create_payment_method-us_bank_account).

    - `account_number` (string) **required**
      The customer’s bank account number.

    - `routing_number` (string) **required**
      The routing number of the customer’s bank.

    - `account_holder_type` (string) **required**
      Account holder type: individual or company.

    - `account_type` (string)
      Account type: checkings or savings. Defaults to checking if omitted.

### Confirm with bank account information

```js
stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      us_bank_account: {
        routing_number: '110000000',
        account_number: '000123456789',
        account_holder_type: 'individual',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      us_bank_account: {
        routing_number: '110000000',
        account_number: '000123456789',
        account_holder_type: 'individual',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Confirm an ACH Direct Debit setup

```js
stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      us_bank_account: {
        routing_number: '110000000',
        account_number: '000123456789',
        account_holder_type: 'individual',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmUsBankAccountSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      us_bank_account: {
        routing_number: '110000000',
        account_number: '000123456789',
        account_holder_type: 'individual',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

## Confirm a Canadian pre-authorized debit setup

Use `stripe.confirmAcssDebitSetup` in the [Save bank details](/payments/acss-debit/set-up-payment.md) flow to set up a [Canadian pre-authorized debit](/payments/acss-debit.md) payment method for future payments.
When called, it will automatically pop up a modal to collect bank account details and verification, accept the mandate, and confirm the [SetupIntent](/api/setup_intents.md) when the user submits the form.
Note that there are some additional requirements to this flow that are not covered in this reference.
Refer to our [integration guide](/payments/acss-debit/set-up-payment.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
`stripe.confirmAcssDebitSetup` automatically creates a new `PaymentMethod` for you when your customer completes the modal UI.
It can also be called with an existing `PaymentMethod`, which will load the modal UI to collect a new mandate agreement.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmAcssDebitSetup` may take several seconds to complete.
> During that time, disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, show it to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmAcssDebitSetup` will return a `Promise` which resolves with a result object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api#errors) and our [integration guide](/payments/acss-debit/set-up-payment) for all possible errors.

**Syntax:** `stripe.confirmAcssDebitSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

- `options` (object)
  An options object to control the behavior of this method.

  - `skipMandate` (boolean)
    Set this to `true` if you want to skip displaying the mandate confirmation.

### Use case: with a new PaymentMethod

You can pass in the customer’s billing details to create a new `PaymentMethod` and confirm the `SetupIntent`.
You are required to collect and include the customer’s name and email address. This method loads an on-page modal UI
that handles bank account details collection and verification, presents a hosted mandate agreement and collects authorization for you.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using data collected.

  - `billing_details` (Object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name. The first and last name must be at minimum 2 characters each.

    - `email` (string) **required**
      The customer's email.

### Confirm with a new PaymentMethod

```js
stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Use case: with an existing PaymentMethod

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmAcssDebitSetup`.
This method loads an on-page modal UI that only presents a hosted mandate agreement and collects authorization for you.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing [PaymentMethod](/api/payment_methods.md).

### Confirm with an existing PaymentMethod

```js
stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Use case: with an attached PaymentMethod

If you have already attached a `PaymentMethod` to this `SetupIntent`, then you can confirm the `SetupIntent` without passing in any additional data.
This method loads an on-page modal UI that only presents a hosted mandate agreement and collects authorization for you.

### Confirm with an attached PaymentMethod

```js
stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {}
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {}
);
if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Use case: with self collected bank account information

If you already know the customer’s bank account information, or want to collect it yourself, you can pass them in directly to create a new `PaymentMethod` and confirm the `SetupIntent`.
In this case, this method does not load the on-page modal UI, so you will need to [build your own mandate agreement page](/payments/acss-debit/custom-pad-agreement.md).

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using data collected.

  - `billing_details` (Object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name. The first and last name must be at minimum 2 characters each.

    - `email` (string) **required**
      The customer's email.

  - `acss_debit` (Object) **required**
    The customer's [bank account information](/api/payment_methods/create.md#create_payment_method-acss_debit).

    - `account_number` (string) **required**
      The customer’s bank account number.

    - `institution_number` (string) **required**
      The institution number of the customer’s bank.

    - `transit_number` (string) **required**
      The transit number of the customer’s bank.

### Confirm with bank account information

```js
stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      acss_debit: {
        institution_number: '000',
        transit_number: '11000',
        account_number: '000123456789',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      acss_debit: {
        institution_number: '000',
        transit_number: '11000',
        account_number: '000123456789',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Use case: with an existing PaymentMethod but skip mandate display

If you have already created a `PaymentMethod` and built your own mandate agreement page,
you can reuse it by passing its `id` to `payment_method` when calling `stripe.confirmAcssDebitSetup` and skip the on-page modal UI at the same time.

### Data and options argument paramters

- `data` (object)
  Data to be sent with the request.

  - `payment_method` (string) **required**
    The `id` of an existing [PaymentMethod](/api/payment_methods.md).

- `options` (object)
  An options object to control the behavior of this method.

  - `skipMandate` (boolean) **required**
    Set to `true` to skip the on-page modal UI.

### Confirm with an existing PaymentMethod but skip mandate display

```js
stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
  {
    skipMandate: true,
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
  {
    skipMandate: true,
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

### Confirm Canadian pre-authorized debit setup

```js
stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else {
    // Handle next step based on SetupIntent's status.
    console.log("SetupIntent ID: " + result.setupIntent.id);
    console.log("SetupIntent status: " + result.setupIntent.status);
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmAcssDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(error.message);
} else {
  // Handle next step based on SetupIntent's status.
  console.log("SetupIntent ID: " + setupIntent.id);
  console.log("SetupIntent status: " + setupIntent.status);
}
```

## Confirm BECS Debit setup

Use `stripe.confirmAuBecsDebitSetup` in the [BECS Direct Debit Payments](/payments/au-becs-debit.md) flow when the customer submits your payment form.
When called, it will confirm the [SetupIntent](/api/setup_intents.md) with `data` you provide.
Note that there are some additional requirements to this flow that are not covered in this reference.
Refer to our [integration guide](/payments/au-becs-debit.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmAuBecsDebitSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmAuBecsDebitSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmAuBecsDebitSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

### Use case: with payment data from an Element

Create and attach a new `PaymentMethod` with `stripe.confirmAuBecsDebitSetup` by passing an `auBankAccount` [Element](/js/element.md) to `payment_method[au_becs_debit]`.
The new `PaymentMethod` will be created with the data collected by the `Element` and will be used to confirm the `SetupIntent`.
Additionally, to create a BECS Direct Debit `PaymentMethod`, you are required to collect and include the account holder's name and the customer’s email address.

### Data argument properties

- `payment_method` (object) **required**
  Pass an `object` to confirm using data collected by an `auBankAccount`
Element.

  - `au_becs_debit` (Element) **required**
    An `auBankAccount` [Element](/js/element.md).

  - `billing_details` (Object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name.

    - `email` (string) **required**
      The customer's email.

### Confirm with an Element

```js
stripe
  .confirmAuBecsDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      au_becs_debit: auBankAccountElement,
      billing_details: {
        name: 'John Smith',
        email: 'john.smith@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmAuBecsDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      au_becs_debit: auBankAccountElement,
      billing_details: {
        name: 'John Smith',
        email: 'john.smith@example.com',
      },
    },
  },
);
```

### Use case: with an existing payment method

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmAuBecsDebitSetup` and it will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

### Confirm with existing payment method

```js
stripe
  .confirmAuBecsDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmAuBecsDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Use case: with self collected data

If you already know the customer’s BSB number and bank account number or want to collect it yourself, then you do not need to use the `auBankAccount` [Element](/js/element.md).
You can pass in the customer’s bank account information directly to create a new `PaymentMethod` and confirm the `SetupIntent`.
Additionally, to create a BECS Direct Debit `PaymentMethod`, you are required to collect and include the account holder's name and the customer's email address.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using data collected without an `Element`.

  - `au_becs_debit` (object) **required**
    An object of self-collected bank account data.

    - `bsb_number` (string) **required**
      A Bank State Branch (BSB) number.

    - `account_number` (string) **required**
      A bank account number.

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The account holder's name.

    - `email` (string) **required**
      The customer's email.

### Confirm with self collected data

```js
stripe
  .confirmAuBecsDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      au_becs_debit: {
        bsb_number: '000000',
        account_number: '000123456'
      },
      billing_details: {
        name: 'John Smith',
        email: 'john.smith@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmAuBecsDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      au_becs_debit: {
        bsb_number: '000000',
        account_number: '000123456'
      },
      billing_details: {
        name: 'John Smith',
        email: 'john.smith@example.com',
      },
    },
  },
);
```

### Confirm BECS Debit setup

```js
stripe
  .confirmAuBecsDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      au_becs_debit: auBankAccountElement,
      billing_details: {
        name: 'John Smith',
        email: 'john.smith@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmAuBecsDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      au_becs_debit: auBankAccountElement,
      billing_details: {
        name: 'John Smith',
        email: 'john.smith@example.com',
      },
    },
  },
);
```

## Confirm Bacs Debit setup

Use `stripe.confirmBacsDebitSetup` in the [Bacs Direct Debit Payments](/payments/payment-methods/bacs-debit.md) flow when the customer submits your payment form.
When called, it will confirm the [SetupIntent](/api/setup_intents.md) with `data` you provide.
Note that there are some additional requirements to this flow that are not covered in this reference.
Refer to our [integration guide](/payments/payment-methods/bacs-debit.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmBacsDebitSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmBacsDebitSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmBacsDebitSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

### Use case: with self collected data

You can also pass in the customer’s bank account information directly to create a new `PaymentMethod` and confirm the `SetupIntent`.
Additionally, to create a Bacs Direct Debit `PaymentMethod`, you are required to collect and include the account holder's name and the customer's email address.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using payment method data.

  - `bacs_debit` (object) **required**
    An object of self-collected bank account data.

    - `account_number` (string) **required**
      A bank account number.

    - `sort_code` (string) **required**
      A sort code.

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `address` (string) **required**
      The account holder's address.

      - `line1` (string) **required**
        Line 1 of the account holder's address.

      - `city` (string) **required**
        The account holder's city.

      - `country` (string) **required**
        The account holder's country.

      - `postal_code` (string) **required**
        The account holder's postal code.

    - `name` (string) **required**
      The account holder's name.

    - `email` (string) **required**
      The customer's email.

### Confirm with self collected data

```js
stripe
  .confirmBacsDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      bacs_debit: {
        sort_code: '108800',
        account_number: '000123456'
      },
      billing_details: {
        address: {
          line1: addressLine1,
          city: addressCity,
          country: addressCountry,
          postal_code: addressPostalCode,
        },
        email: customerEmail,
        name: customerName,
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmBacsDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      bacs_debit: {
        sort_code: '108800',
        account_number: '000123456'
      },
      billing_details: {
        address: {
          line1: addressLine1,
          city: addressCity,
          country: addressCountry,
          postal_code: addressPostalCode,
        },
        email: customerEmail,
        name: customerName,
      },
    },
  },
);
```

### Use case: with an existing payment method

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmBacsDebitSetup` and it will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

### Confirm with existing payment method

```js
stripe
  .confirmBacsDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmBacsDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Confirm Bacs Debit setup

```js
stripe
  .confirmBacsDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      bacs_debit: {
        sort_code: '108800',
        account_number: '000123456'
      },
      billing_details: {
        address: {
          line1: addressLine1,
          city: addressCity,
          country: addressCountry,
          postal_code: addressPostalCode,
        },
        email: customerEmail,
        name: customerName,
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmBacsDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      bacs_debit: {
        sort_code: '108800',
        account_number: '000123456'
      },
      billing_details: {
        address: {
          line1: addressLine1,
          city: addressCity,
          country: addressCountry,
          postal_code: addressPostalCode,
        },
        email: customerEmail,
        name: customerName,
      },
    },
  },
);
```

## Confirm Bancontact setup

Use `stripe.confirmBancontactSetup` in the [Set up future payments](/payments/bancontact/set-up-payment.md) flow to use Bancontact bank details to set up a
SEPA Direct Debit payment method for future payments. When called, it will confirm a `SetupIntent` with `data` you provide, and it will
automatically redirect the customer to authorize the transaction. Once authorization is complete, the customer will be redirected back to your specified `return_url`.
Note that there are some additional requirements to this flow that are not covered in this reference.
Refer to our [integration guide](/payments/bancontact/set-up-payment.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmBancontactSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmBancontactSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmBancontactSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

  - `return_url` (string)
    The url your customer will be directed to after they complete authentication.

- `options` (object)
  An options object to control the behavior of this method.

  - `handleActions` (boolean)
    Set this to `false` if you want to [manually handle the authorization redirect](/payments/bancontact/accept-a-payment?platform=web.md#handle-redirect).
Default is `true`.

### Use case: with an existing payment method

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmBancontactSetup` and it will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

- `return_url` (string)
  The url your customer will be directed to after they complete authentication.

### Confirm with existing payment method

```js
stripe
  .confirmBancontactSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmBancontactSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Use case: with self collected data

Your customer's name and email are required for the Bancontact authorization to succeed.
You can pass in these properties directly to create a new `PaymentMethod` and confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm with the customer's name and email.

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name.

    - `email` (string) **required**
      The customer's email.

- `return_url` (string)
  The url your customer will be directed to after they complete authentication.

### Confirm with self collected data

```js
stripe
  .confirmBancontactSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmBancontactSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  },
);
```

### Confirm Bancontact setup

```js
stripe
  .confirmBancontactSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmBancontactSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  },
);
```

## Confirm an Cash App Pay setup

Use `stripe.confirmCashappSetup` in the [Save payment details](/payments/cash-app-pay/set-up-payment.md) flow for the [Cash App Pay](/payments/cash-app-pay.md) payment method to record the customer’s authorization for future payments.

When you confirm a [SetupIntent](/api/setup_intents.md), it needs to have an attached [PaymentMethod](/api/payment_methods.md).

In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
If you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmCashappSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

By default, `stripe.confirmCashappSetup` will display Cash App Pay QR code in desktop web app, or trigger a redirect in mobile web app. If
there is an error, or when handling next actions manually by using the
`handleActions: false` option, it will return a `Promise` which resolves with a `result`
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api#errors) and our [integration guide](/payments/cash-app-pay/set-up-payment) for all possible errors.

**Syntax:** `stripe.confirmCashappSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

  - `return_url` (string) **required**
    The url your customer will be directed to after they complete authentication.

- `options` (object)
  An options object to control the behavior of this method.

  - `handleActions` (boolean)
    Set this to `false` if you would like to [handle displaying the Cash App Pay QR code or handle the authorization redirect](docs/payments/cash-app-pay/set-up-payment?platform=web&ui=API#web-create-setup-intent) yourself.

### Use case: Without an existing payment method

If you have not already created a `PaymentMethod`, you can pass payment method parameters, and the newly created `PaymentMethod` will be used to confirm the `SetupIntent`.

### Data argument properties

- `return_url` (string) **required**
  The url your customer will be directed to after they complete authentication.

### Confirm with bank account information

```js
stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      type: 'cashapp',
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href
  }
).then(function(error, setupIntent) {
  if (error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else if (setupIntent.status === 'succeeded') {
    // Inform the customer that the payment was successful
  } else if (setupIntent.status === 'requires_action'){
    // Inform the customer that the payment did not go through
  }
});
```

```es_next
const {error, setupIntent} = await stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      type: 'cashapp',
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href
  }
);

if (error) {
  // Inform the customer that there was an error.
} else if (setupIntent.status === 'succeeded') {
  // Inform the customer that the payment was successful
} else if (setupIntent.status === 'requires_action') {
  // Inform the customer that the payment did not go through
}
```

### Use case: with an existing PaymentMethod

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmCashappSetup`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing [PaymentMethod](/api/payment_methods.md).

- `return_url` (string) **required**
  The url your customer will be directed to after they complete authentication.

### Confirm with an existing PaymentMethod

```js
stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href
  }
).then(function({error, setupIntent}) {
  if (error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else if (setupIntent.status === 'succeeded') {
    // Inform the customer that the payment was successful
  } else if (setupIntent.status === 'requires_action'){
    // Inform the customer that the payment did not go through
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href
  }
);

if (error) {
  // Inform the customer that there was an error.
  console.log(result.error.message);
} else if (setupIntent.status === 'succeeded') {
  // Inform the customer that the payment was successful
} else if (setupIntent.status === 'requires_action'){
  // Inform the customer that the payment did not go through
}
```

### Use case: with an attached PaymentMethod

If you have already attached a `return_url` and a `PaymentMethod` to this `SetupIntent`, then you can confirm without passing in any additional data.

### Confirm with an attached PaymentMethod

```js
stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}'
).then(function({setupIntent, error}) {
  if (error) {
    // Inform the customer that there was an error.
  } else if (setupIntent.status === 'succeeded') {
    // Inform the customer that the payment was successful
  } else if (setupIntent.status === 'requires_action') {
    // Inform the customer that the payment did not go through
  }
});
```

```es_next
const {setupIntent, error} = await stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}'
);
if (error) {
  // Inform the customer that there was an error.
} else if (setupIntent.status === 'succeeded') {
  // Inform the customer that the payment was successful
} else if (setupIntent.status === 'requires_action') {
  // Inform the customer that the payment did not go through
}
```

### Confirm a Cash App Pay setup

```js
stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      type: 'cashapp',
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href
  }
).then(function(error, setupIntent) {
  if (error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  } else if (setupIntent.status === 'succeeded') {
    // Inform the customer that the payment was successful
  } else if (setupIntent.status === 'requires_action'){
    // Inform the customer that the payment did not go through
  }
});
```

```es_next
const {error, setupIntent} = await stripe.confirmCashappSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      type: 'cashapp',
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href
  }
);

if (error) {
  // Inform the customer that there was an error.
} else if (setupIntent.status === 'succeeded') {
  // Inform the customer that the payment was successful
} else if (setupIntent.status === 'requires_action') {
  // Inform the customer that the payment did not go through
}
```

## Confirm Indonesia bank transfer setup

Use `stripe.confirmIdBankTransferSetup` in the [Reusable virtual bank accounts](/payments/id-bank-transfer/accept-a-payment/reusable-virtual-bank-accounts.md) flow to set up an Indonesia bank transfer payment method for future payments.
When called, it will confirm a `SetupIntent` with `data` you provide.
Note that there are some additional recommendations to this flow on why you should collect the customer's name, email, and bank preference.
Refer to our [integration guide](/payments/id-bank-transfer/accept-a-payment/reusable-virtual-bank-accounts.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmIdBankTransferSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmIdBankTransferSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmIdBankTransferSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

### Use case: with a new PaymentMethod

You can confirm the `SetupIntent` using `stripe.confirmIdBankTransferSetup` without
passing in any additional data. This will automatically create and attach a new
`PaymentMethod`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using collected data.

  - `id_bank_transfer` (object) **required**
    An object detailing the customer's bank.

    - `bank` (string) **required**
      The customer's [bank](/api/payment_methods/create.md#create_payment_method-id_bank_transfer-bank).

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` is required and `email` is recommended.

    - `name` (string) **required**
      The customer's name.

    - `email` (string)
      The customer's email.

### Confirm with a new PaymentMethod

```js
stripe
  .confirmIdBankTransferSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      id_bank_transfer: {
        bank: 'bni',
      },
      billing_details: {
        name: 'Fitri Sari',
        email: 'fitrisari@example.com',
      },
    },
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmIdBankTransferSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      id_bank_transfer: {
        bank: 'bni',
      },
      billing_details: {
        name: 'Fitri Sari',
        email: 'fitrisari@example.com',
      },
    },
  },
);
```

### Use case: with an existing payment method

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmIdBankTransferSetup` and it will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

### Confirm with existing payment method

```js
stripe
  .confirmIdBankTransferSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmIdBankTransferSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Use case: with an attached PaymentMethod

If you have already attached a `PaymentMethod` to this `SetupIntent`, then you can confirm the `SetupIntent` using `stripe.confirmIdBankTransferSetup` without passing in any additional data.

### Confirm with an attached PaymentMethod

```js
stripe
  .confirmIdBankTransferSetup('{SETUP_INTENT_CLIENT_SECRET}', {})
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmIdBankTransferSetup();
```

### Confirm Indonesia bank transfer setup

```js
stripe
  .confirmIdBankTransferSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      id_bank_transfer: {
        bank: 'bni',
      },
      billing_details: {
        name: 'Fitri Sari',
        email: 'fitrisari@example.com',
      },
    },
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmIdBankTransferSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      id_bank_transfer: {
        bank: 'bni',
      },
      billing_details: {
        name: 'Fitri Sari',
        email: 'fitrisari@example.com',
      },
    },
  },
);
```

## Confirm iDEAL setup

Use `stripe.confirmIdealSetup` in the [Set up future payments](/payments/ideal/set-up-payment.md) flow to use iDEAL bank details to set up a
SEPA Direct Debit payment method for future payments. When called, it will confirm a `SetupIntent` with `data` you provide, and it will
automatically redirect the customer to authorize the transaction. Once authorization is complete, the customer will be redirected back to your specified `return_url`.
Note that there are some additional requirements to this flow that are not covered in this reference.
Refer to our [integration guide](/payments/ideal/set-up-payment.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmIdealSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmIdealSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmIdealSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

  - `return_url` (string)
    The url your customer will be directed to after they complete authentication.

- `options` (object)
  An options object to control the behavior of this method.

  - `handleActions` (boolean)
    Set this to `false` if you want to [manually handle the authorization redirect](/payments/ideal/accept-a-payment?platform=web.md#web-handle-redirect).
Default is `true`.

### Use case: with payment data from an Element

Create and attach a new SEPA Direct Debit `PaymentMethod` with `stripe.confirmIdealSetup` by passing an `idealBank` [Element](/js/element.md) to `payment_method[ideal]`.
The new `PaymentMethod` will be created with the data collected by the `Element` and will be used to confirm the `SetupIntent`.
Additionally, to create a SEPA Direct Debit `PaymentMethod`, you are required to collect and include the customer’s name and email address.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using data collected by an `idealBank`
Element.

  - `ideal` (Element) **required**
    An `idealBank` [Element](/js/element.md).

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name.

    - `email` (string) **required**
      The customer's email.

- `return_url` (string)
  The url your customer will be directed to after they complete authentication.

### Confirm with an Element

```js
stripe
  .confirmIdealSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      ideal: idealBankElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmIdealSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      ideal: idealBankElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  },
);
```

### Use case: with an existing payment method

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmIdealSetup` and it will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

- `return_url` (string)
  The url your customer will be directed to after they complete authentication.

### Confirm with existing payment method

```js
stripe
  .confirmIdealSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmIdealSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Use case: with self collected data

If you already know the customer’s bank or want to collect it yourself, then you do not need to use the `idealBank` [Element](/js/element.md).
You can pass in the customer’s [bank code](/payments/ideal/accept-a-payment?platform=web&ui=element.md#bank-reference) directly to create a new `PaymentMethod` and confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using data collected by an `idealBank`
Element.

  - `ideal` (object) **required**
    An object detailing the customer's iDEAL bank.

    - `bank` (string) **required**
      The customer's [bank](/payments/ideal/accept-a-payment?platform=web&ui=element.md#bank-reference).

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name.

    - `email` (string) **required**
      The customer's email.

- `return_url` (string)
  The url your customer will be directed to after they complete authentication.

### Confirm with self collected data

```js
stripe
  .confirmIdealSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      ideal: {
        bank: 'abn_amro',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmIdealSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      ideal: {
        bank: 'abn_amro',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  },
);
```

### Confirm iDEAL setup

```js
stripe
  .confirmIdealSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      ideal: idealBankElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmIdealSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      ideal: idealBankElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  },
);
```

## Confirm a Klarna setup

Use `stripe.confirmKlarnaSetup` in the [Klarna Payments with Setup Intents](/payments/klarna/set-up-payment.md) flow when the customer submits your setup form.
When called, it will confirm the `SetupIntent` with `data` you provide, and it will automatically redirect the customer to authorize the setup.
Once authorization is complete, the customer will be redirected back to your specified `return_url`.

> Note that `stripe.confirmKlarnaSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmKlarnaSetup` will trigger a redirect when successful.
If there is an error, it will return a `Promise` which resolves with a `result` object.
This object has either:
* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmKlarnaSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (string | object)
    The `id` of an existing [PaymentMethod](/api/payment_methods.md).
See the use case sections below for details.

  - `return_url` (string) **required**
    The url your customer will be directed to after they complete authentication.

### Use case: with an existing payment method

Use `stripe.confirmKlarnaSetup` with an existing `PaymentMethod` by passing its `id` to `payment_method`.
The `PaymentMethod` will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

- `return_url` (string) **required**
  The url your customer will be directed to after they complete authentication.

### Confirm with existing payment method

```js
stripe
  .confirmKlarnaSetup('{PAYMENT_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer should be redirected after the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmKlarnaSetup(
  '{PAYMENT_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer should be redirected after the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Use case: with an attached PaymentMethod

If you have already attached a `PaymentMethod` to this `SetupIntent`, then you can confirm the `SetupIntent` using `stripe.confirmKlarnaSetup` without passing in any additional data.

### Confirm with an attached PaymentMethod

```js
stripe
  .confirmKlarnaSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmKlarnaSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Use case: with self collected data

Your customer's email and billing country are required for the Klarna authorization to succeed.
You can pass in these properties directly to create a new `PaymentMethod` and confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm with the customer's email and billing country.

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`email` and `address.country` are required.

    - `email` (string) **required**
      The customer's email.

    - `address` (object) **required**
      The customer's billing address.

      - `country` (string) **required**
        The customer's billing country.

- `return_url` (string) **required**
  The url your customer will be directed to after they complete authentication.

### Confirm with self collected data

```js
stripe
  .confirmKlarnaSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      billing_details: {
        email: 'jenny@example.com',
        address: {
          country: 'DE',
        },
      },
    },
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmKlarnaSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Confirm a Klarna setup

```js
stripe
  .confirmKlarnaSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      billing_details: {
        email: 'jenny@example.com',
        address: {
          country: 'DE',
        },
      },
    },
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmKlarnaSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

## Confirm a PayPal setup

Use `stripe.confirmPayPalSetup` in the [PayPal Payments with Setup Intents](/payments/paypal/set-up-payment.md) flow when the customer submits your setup form.
When called, it will confirm the `SetupIntent`, and it will automatically redirect the customer to authorize the setup.
Once authorization is complete, the customer will be redirected back to your specified `return_url`.

> Note that `stripe.confirmPayPalSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmPayPalSetup` will trigger a redirect when successful.
If there is an error, it will return a `Promise` which resolves with a `result` object.
This object has either:
* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmPayPalSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (string | object)
    The `id` of an existing [PaymentMethod](/api/payment_methods.md).
See the use case sections below for details.

  - `return_url` (string) **required**
    The url your customer will be directed to after they complete authentication.

### Use case: with a new PaymentMethod

You can confirm the `SetupIntent` using `stripe.confirmPayPalSetup` without
passing in any additional data. This will automatically create and attach a new
`PaymentMethod`.

### Data argument properties

- `return_url` (string) **required**
  The url your customer will be directed to after they complete authentication.

### Confirm with a new PaymentMethod

```js
stripe
  .confirmPayPalSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmPayPalSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Use case: with an existing payment method

Use `stripe.confirmPayPalSetup` with an existing `PaymentMethod` by passing its `id` to `payment_method`.
The `PaymentMethod` will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

- `return_url` (string) **required**
  The url your customer will be directed to after they complete authentication.

### Confirm with existing payment method

```js
stripe
  .confirmPayPalPayment('{PAYMENT_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer should be redirected after the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmPayPalPayment(
  '{PAYMENT_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer should be redirected after the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Use case: with an attached PaymentMethod

If you have already attached a `PaymentMethod` to this `SetupIntent`, then you can confirm the `SetupIntent` using `stripe.confirmPayPalSetup` without passing in any additional data.

### Confirm with an attached PaymentMethod

```js
stripe
  .confirmPayPalSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmPayPalSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Confirm a PayPal setup

```js
stripe
  .confirmPayPalSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmPayPalSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer should be redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

## Confirm a PayTo setup

Use `stripe.confirmPayToSetup` in the [PayTo Payments with Setup Intents](/payments/payto/set-up-payment.md) flow when the customer submits your setup form.
When called, it will confirm the `SetupIntent`, and send a request for authorization to the customer.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
If you've already attached a `PaymentMethod`, you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmPayToSetup` might take some time to complete while waiting for customers to authorize the PayTo agreement.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

By default, `stripe.confirmPayToSetup` will poll for updates to the `SetupIntent`.
If there's an error, or when handling `next_action`s manually by using the `handleActions: false` option, it returns a `Promise` which resolves with a `result` object.
This object has either:
* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmPayToSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (string | object)
    Either the `id` of an existing [PaymentMethod](/api/payment_methods.md), or an object containing data to create a `PaymentMethod` with.
See the use case sections below for details.

- `options` (object)
  An options object to control the behavior of this method.

  - `handleActions` (boolean)
    Set this to `false` if you want to manually handle polling for SetupIntent updates.
Default is `true`.

### Use case: with a new PaymentMethod

You can confirm the `SetupIntent` using `stripe.confirmPayToSetup` without
passing in any additional data. This will automatically create and attach a new
`PaymentMethod`.

### Data argument properties

- `payment_method` (object) **required**
  Pass payment method billing details.

  - `billing_details` (object) **required**
    The [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details) associated with the payment. The email is required if the customer is paying with PayID.

    - `email` (string)

    - `name` (string) **required**

  - `payto` (object) **required**
    The [PayTo payment method details](/api/payment_methods/create.md#create_payment_method-payto) associated with the customer's bank account. Either `pay_id` or `account_number` and `bsb_number` must be provided.

    - `pay_id` (string)

    - `account_number` (string)

    - `bsb_number` (string)

### Confirm with a new PaymentMethod

```js
stripe
  .confirmPayToSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    {
      payment_method: {
        billing_details: {
          name: 'Jenny Rosen',
          // Email is only required if `pay_id` is used
          email: 'jenny@example.com'
        },
        payto: {
          pay_id: 'jenny@example.com'
          // Alternatively, provide bank account details
          account_number: '000123456',
          bsb_number: '000000'
        }
      }
    }
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmPayToSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        // Email is only required if `pay_id` is used
        email: 'jenny@example.com'
      },
      payto: {
        pay_id: 'jenny@example.com'
        // Alternatively, provide bank account details
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  }
);
```

### Use case: with an existing payment method

Use `stripe.confirmPayToSetup` with an existing `PaymentMethod` by passing its `id` to `payment_method`.
The `PaymentMethod` will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

### Confirm with existing payment method

```js
stripe
  .confirmPayToPayment('{PAYMENT_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}'
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmPayToPayment(
  '{PAYMENT_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}'
  },
);
```

### Use case: with an attached PaymentMethod

If you have already attached a `PaymentMethod` to this `SetupIntent`, then you can confirm the `SetupIntent` using `stripe.confirmPayToSetup` without passing in any additional data.

### Confirm with an attached PaymentMethod

```js
stripe
  .confirmPayToSetup('{SETUP_INTENT_CLIENT_SECRET}')
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmPayToSetup('{SETUP_INTENT_CLIENT_SECRET}');
```

### Confirm a PayTo setup

```js
stripe
  .confirmPayToSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    {
      payment_method: {
        billing_details: {
          name: 'Jenny Rosen',
          // Email is only required if `pay_id` is used
          email: 'jenny@example.com'
        },
        payto: {
          pay_id: 'jenny@example.com'
          // Alternatively, provide bank account details
          account_number: '000123456',
          bsb_number: '000000'
        }
      }
    }
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmPayToSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      billing_details: {
        name: 'Jenny Rosen',
        // Email is only required if `pay_id` is used
        email: 'jenny@example.com'
      },
      payto: {
        pay_id: 'jenny@example.com'
        // Alternatively, provide bank account details
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  }
);
```

## Confirm SEPA Debit setup

Use `stripe.confirmSepaDebitSetup` in the [SEPA Direct Debit with Setup Intents](/payments/sepa-debit-setup-intents.md) flow when the customer submits your payment form.
When called, it will confirm the `SetupIntent` with `data` you provide.
Note that there are some additional requirements to this flow that are not covered in this reference.
Refer to our [integration guide](/payments/sepa-debit-setup-intents.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmSepaDebitSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmSepaDebitSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmSepaDebitSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

### Use case: with payment data from an Element

Create and attach a new `PaymentMethod` with `stripe.confirmSepaDebitSetup` by passing an `iban` [Element](/js/element.md) to `payment_method[sepa_debit]`.
The new `PaymentMethod` will be created with the data collected by the `Element` and will be used to confirm the `SetupIntent`.
Additionally, to create a SEPA Direct Debit `PaymentMethod`, you are required to collect and include the customer’s name and email address.

### Data argument properties

- `payment_method` (object) **required**
  Pass an `object` to confirm using data collected by an `iban`
Element.

  - `sepa_debit` (Element) **required**
    An `iban` [Element](/js/element.md).

  - `billing_details` (Object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name.

    - `email` (string) **required**
      The customer's email.

### Confirm with an Element

```js
stripe
  .confirmSepaDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      sepa_debit: ibanElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmSepaDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      sepa_debit: ibanElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  },
);
```

### Use case: with an existing payment method

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmSepaDebitSetup` and it will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

### Confirm with existing payment method

```js
stripe
  .confirmSepaDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmSepaDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Use case: with self collected data

If you already know the customer’s IBAN account number or want to collect it yourself, then you do not need to use the `iban` [Element](/js/element.md).
You can pass in the customer’s account number directly to create a new `PaymentMethod` and confirm the `SetupIntent`.
Additionally, to create a SEPA Direct Debit `PaymentMethod`, you are required to collect and include the customer’s name and email address.

### Data argument properties

- `payment_method` (object) **required**
  Pass an `object` to confirm using data collected by an `iban`
Element.

  - `sepa_debit` (object) **required**
    An object of self-collected IBAN data.

    - `iban` (string) **required**
      An IBAN account number.

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name.

    - `email` (string) **required**
      The customer's email.

### Confirm with self collected data

```js
stripe
  .confirmSepaDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      sepa_debit: {
        iban: 'DE89370400440532013000',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmSepaDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      sepa_debit: {
        iban: 'DE89370400440532013000',
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  },
);
```

### Confirm SEPA Debit setup

```js
stripe
  .confirmSepaDebitSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      sepa_debit: ibanElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmSepaDebitSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      sepa_debit: ibanElement,
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
  },
);
```

## Confirm Sofort setup

Use `stripe.confirmSofortSetup` in the [Set up future payments](/payments/sofort/set-up-payment.md) flow to use SOFORT bank details to set up a
SEPA Direct Debit payment method for future payments. When called, it will confirm a `SetupIntent` with `data` you provide, and it will
automatically redirect the customer to authorize the transaction. Once authorization is complete, the customer will be redirected back to your specified `return_url`.
Note that there are some additional requirements to this flow that are not covered in this reference.
Refer to our [integration guide](/payments/sofort/set-up-payment.md) for more details.

When you confirm a `SetupIntent`, it needs to have an attached [PaymentMethod](/api/payment_methods.md).
In addition to confirming the `SetupIntent`, this method can automatically create and attach a new `PaymentMethod` for you.
It can also be called with an existing `PaymentMethod`, or if you have already attached a `PaymentMethod` you can call this method without needing to provide any additional data.
These use cases are detailed in the sections that follow.

> Note that `stripe.confirmSofortSetup` may take several seconds to complete.
> During that time, you should disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, you should be sure to show that error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmSofortSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api#errors) for all possible errors.

**Syntax:** `stripe.confirmSofortSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    The `id` of an existing PaymentMethod or an object of collected data.
See use cases below for details.

  - `return_url` (string)
    The url your customer will be directed to after they complete authentication.

- `options` (object)
  An options object to control the behavior of this method.

  - `handleActions` (boolean)
    Set this to `false` if you want to [manually handle the authorization redirect](/payments/sofort/accept-a-payment?platform=web.md#handle-redirect).
Default is `true`.

### Use case: with an existing payment method

If you have already created a `PaymentMethod`, you can pass its `id` to `payment_method` when calling `stripe.confirmSofortSetup` and it will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

- `return_url` (string)
  The url your customer will be directed to after they complete authentication.

### Confirm with existing payment method

```js
stripe
  .confirmSofortSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
  })
  .then(function(result) {
    // Handle result.error or result.setupIntent
  });
```

```es_next
const {error, setupIntent} = await stripe.confirmSofortSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
  },
);
```

### Use case: with self collected data

Your customer's name, email and the country of their bank are required for the SOFORT authorization to succeed.
You can pass in these properties directly to create a new `PaymentMethod` and confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm with the customer's name and email.

  - `country` (string) **required**
    The country code where customer's bank is located.

  - `billing_details` (object) **required**
    The customer's [billing_details](/api/payment_methods/create.md#create_payment_method-billing_details).
`name` and `email` are required.

    - `name` (string) **required**
      The customer's name.

    - `email` (string) **required**
      The customer's email.

- `return_url` (string)
  The url your customer will be directed to after they complete authentication.

### Confirm with self collected data

```js
stripe
  .confirmSofortSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      sofort: {
        country: 'DE'
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmSofortSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      sofort: {
        country: 'DE'
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  },
);
```

### Confirm SOFORT setup

```js
stripe
  .confirmSofortSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      sofort: {
        country: 'DE'
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmSofortSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: {
      sofort: {
        country: 'DE'
      },
      billing_details: {
        name: 'Jenny Rosen',
        email: 'jenny@example.com',
      },
    },
    // Return URL where the customer should be redirected after the authorization.
    return_url: window.location.href,
  },
);
```

## Confirm TWINT setup

Use `stripe.confirmTwintSetup` in the [TWINT Payments with Setup Intents](/payments/twint/set-up-future-payments.md) flow when the customer submits your setup form.
When called, it confirms the `SetupIntent`, and automatically redirects the customer to authorize the setup.
After authorization is complete, the customer is redirected back to your specified `return_url`.

> Note that `stripe.confirmTwintSetup` might take some time to complete while waiting for customers to authorize the setup.
> During that time, disable your form from being resubmitted and show a waiting indicator like a spinner.
> If you receive an error result, make sure to show the error to the customer, re-enable the form, and hide the waiting indicator.

`stripe.confirmTwintSetup` will return a `Promise` which resolves with a `result` object.
This object has either:

* `result.setupIntent`: the successful [SetupIntent](/api/setup_intents).
* `result.error`: an error.
  Refer to the [API reference](/api/errors) for all possible errors.

**Syntax:** `stripe.confirmTwintSetup(...)`

- `clientSecret` (string) **required**
  The [client secret](/api/setup_intents/object.md#setup_intent_object-client_secret) of the `SetupIntent`.

- `data` (object)
  Data to be sent with the request.
Refer to the [Setup Intents API](/api/setup_intents/confirm.md) for a full list of parameters.

  - `payment_method` (object | string)
    An object of collected data or an `id` of an existing [PaymentMethod](/api/payment_methods.md).
See the use cases below for details.

  - `return_url` (string) **required**
    The URL your customer is redirected to after they complete authorization.

- `options` (object)
  An options object to control the behavior of this method.

  - `handleActions` (boolean)
    Set this to `false` if you want to manually handle the authorization redirect.
Default is `true`.

### Use case: with a new PaymentMethod

If you haven't already created a `PaymentMethod`, you can pass payment method parameters, and the newly created `PaymentMethod` will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (object) **required**
  Pass an object to confirm using collected data.

  - `type` (string) **required**
    A `twint` type.

- `return_url` (string) **required**
  The URL your customer is redirected to after they complete authorization.

### Confirm with a new PaymentMethod

```js
stripe
  .confirmTwintSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      type: 'twint',
    },
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmTwintSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Use case: with an existing payment method

Use `stripe.confirmTwintSetup` with an existing `PaymentMethod` by passing its `id` to `payment_method`.
The `PaymentMethod` will be used to confirm the `SetupIntent`.

### Data argument properties

- `payment_method` (string) **required**
  The `id` of an existing `PaymentMethod`.

- `return_url` (string) **required**
  The URL your customer is redirected to after they complete authorization.

### Confirm with existing payment method

```js
stripe
  .confirmTwintSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmTwintSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    payment_method: '{PAYMENT_METHOD_ID}',
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Use case: with an attached PaymentMethod

If you've already attached a `PaymentMethod` to this `SetupIntent`, then you can confirm the `SetupIntent` using `stripe.confirmTwintSetup` by passing a `return_url`.

### Data argument properties

- `return_url` (string) **required**
  The URL your customer is redirected to after they complete authorization.

### Confirm with an attached PaymentMethod

```js
stripe
  .confirmTwintSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {setupIntent, error} = await stripe.confirmTwintSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```

### Confirm TWINT setup

```js
stripe
  .confirmTwintSetup('{SETUP_INTENT_CLIENT_SECRET}', {
    payment_method: {
      type: 'twint',
    },
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  })
  .then(function(result) {
    if (result.error) {
      // Inform the customer that there was an error.
    }
  });
```

```es_next
const {error} = await stripe.confirmTwintSetup(
  '{SETUP_INTENT_CLIENT_SECRET}',
  {
    // Return URL where the customer is redirected after
    // the authorization.
    return_url: "https://example.com/setup/complete",
  },
);
```