Payments
Card payments
Add payment methods
Stripe Checkout
About the APIs
Regulation Support
Sign in
Support
Sign in
Sign up
Payments
More payment scenarios
Set up future payments
HomePaymentsMore payment scenarios

Set up future payments

Learn how to save card details and charge your customers later.

Collecting payment details using Checkout’s setup mode is useful for setting up a payment method on file for future payments. Setup mode uses the Setup Intents API to create Payment Methods.

1 Set up Stripe Server-side

First, you need a Stripe account. Register now.

Use our official libraries for access to the Stripe API from your application:

# Available as a gem
gem install stripe
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
# Install through pip
pip install --upgrade stripe
# Or find the Stripe package on http://pypi.python.org/pypi/stripe/
# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0
# Install the PHP library via Composer
composer require stripe/stripe-php
# Or download the source directly: https://github.com/stripe/stripe-php/releases
/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"
<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>
# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson
# Install via npm
npm install --save stripe
# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71
// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)
# Install via dotnet
dotnet add package Stripe.net
dotnet restore
# Or install via NuGet
PM> Install-Package Stripe.net

2 Create a Checkout Session Server-side

To create a setup mode Session, use the mode parameter with a value of setup when creating the Session. You can optionally specify the customer parameter to automatically attach the created payment method to an existing customer. See the Checkout Session API reference for a complete list of parameters that you can use for Session creation.

Append the {CHECKOUT_SESSION_ID} template variable to the success_url to get access to the Session ID after your customer successfully completes a Checkout Session.

curl https://api.stripe.com/v1/checkout/sessions \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d "payment_method_types[]"=card \
  -d mode=setup \
  -d customer=cus_FOsk5sbh3ZQpAU \
  -d success_url="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \
  -d cancel_url="https://example.com/cancel"

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

session = Stripe::Checkout::Session.create(
  payment_method_types: ['card'],
  mode: 'setup',
  customer: 'cus_FOsk5sbh3ZQpAU'
  success_url: 'https://example.com/success?session_id={CHECKOUT_SESSION_ID}',
  cancel_url: 'https://example.com/cancel',
)

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

session = stripe.checkout.Session.create(
  payment_method_types=['card'],
  mode='setup',
  customer='cus_FOsk5sbh3ZQpAU',
  success_url='https://example.com/success?session_id={CHECKOUT_SESSION_ID}',
  cancel_url='https://example.com/cancel',
)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$session = \Stripe\Checkout\Session::create([
  'payment_method_types' => ['card'],
  'mode' => 'setup',
  'customer' => 'cus_FOsk5sbh3ZQpAU',
  'success_url' => 'https://example.com/success?session_id={CHECKOUT_SESSION_ID}',
  'cancel_url' => 'https://example.com/cancel',
]);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

SessionCreateParams params =
  SessionCreateParams.builder()
    .addPaymentMethodType(SessionCreateParams.PaymentMethodType.CARD)
    .setMode(SessionCreateParams.Mode.SETUP)
    .setCustomer("cus_FOsk5sbh3ZQpAU")
    .setSuccessUrl("https://example.com/success?session_id={CHECKOUT_SESSION_ID}")
    .setCancelUrl("https://example.com/cancel")
    .build();

Session session = Session.create(params);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const session = await stripe.checkout.sessions.create({
  payment_method_types: ['card'],
  mode: 'setup',
  customer: 'cus_FOsk5sbh3ZQpAU',
  success_url: 'https://example.com/success?session_id={CHECKOUT_SESSION_ID}',
  cancel_url: 'https://example.com/cancel',
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.CheckoutSessionParams{
    PaymentMethodTypes: stripe.StringSlice([]string{
        "card",
    }),
    Mode: stripe.String(string(stripe.CheckoutSessionModeSetup)),
    Customer: stripe.String("cus_FOsk5sbh3ZQpAU"),
    SuccessURL: stripe.String("https://example.com/success?session_id={CHECKOUT_SESSION_ID}"),
    CancelURL: stripe.String("https://example.com/cancel"),
}

session, err := session.New(params)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var options = new SessionCreateOptions {
    PaymentMethodTypes = new List<string> {
        "card",
    },
    Mode = "setup",
    Customer = "cus_FOsk5sbh3ZQpAU,
    SuccessUrl = "https://example.com/success?session_id={CHECKOUT_SESSION_ID}",
    CancelUrl = "https://example.com/cancel",
};

var service = new SessionService();
var session = service.Create(options);

Your Stripe.js integration needs the id field from the Session creation API response, so be sure to make it available to the JavaScript or HTML file you call redirectToCheckout from.

3 Redirect to Checkout Client-side

Checkout relies on Stripe.js, Stripe’s foundational JavaScript library for building payment flows.

To get started, include the following script tag on your website—always load it directly from https://js.stripe.com. You can’t include it in a bundle or host it yourself. See Stripe samples for examples.

<script src="https://js.stripe.com/v3/"></script>

npm install @stripe/stripe-js

Next, create an instance of the Stripe object by providing your publishable API key as the first parameter:

var stripe = Stripe('pk_test_TYooMQauvdEDq54NiTphI7jx');

import {loadStripe} from '@stripe/stripe-js';

const stripe = await loadStripe('pk_test_TYooMQauvdEDq54NiTphI7jx');

To use Checkout on your website, you must add a snippet of code that includes the Session id from the previous step. When your customer is ready to save their payment method, call redirectToCheckout and provide the Session id as a parameter.

var checkoutButton = document.getElementById('checkout-button');

checkoutButton.addEventListener('click', function() {
  stripe.redirectToCheckout({
    // Make the id field from the Checkout Session creation API response
    // available to this file, so you can provide it as argument here
    // instead of the {{CHECKOUT_SESSION_ID}} placeholder.
    sessionId: '{{CHECKOUT_SESSION_ID}}'
  }).then(function (result) {
    // If `redirectToCheckout` fails due to a browser or network
    // error, display the localized error message to your customer
    // using `result.error.message`.
  });
});
const checkoutButton = document.getElementById('checkout-button');

checkoutButton.addEventListener('click', () => {
  stripe.redirectToCheckout({
    // Make the id field from the Checkout Session creation API response
    // available to this file, so you can provide it as argument here
    // instead of the {{CHECKOUT_SESSION_ID}} placeholder.
    sessionId: '{{CHECKOUT_SESSION_ID}}'
  })
  // If `redirectToCheckout` fails due to a browser or network
  // error, display the localized error message to your customer
  // using `error.message`.
});

To get started, install the Stripe.js module. Always load Stripe.js directly from https://js.stripe.com. You can’t include it in a bundle or host it yourself.

npm install @stripe/stripe-js

Add Stripe.js to your page

Call loadStripe with your publishable key. It returns a Promise that resolves with the Stripe object once Stripe.js has loaded.

When your customer is ready to save their payment method, call redirectToCheckout and provide the Session id as a parameter.

import React from 'react';
import ReactDOM from 'react-dom';
import { loadStripe } from '@stripe/stripe-js';
// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('pk_test_TYooMQauvdEDq54NiTphI7jx');

function App() {
  const handleClick = async (event) => {
    // Call your backend to create the Checkout session.
    const { sessionId } = await fetchCheckoutSession();
    // When the customer clicks on the button, redirect them to Checkout.
    const stripe = await stripePromise;
    const { error } = await stripe.redirectToCheckout({
      sessionId,
    });
    // If `redirectToCheckout` fails due to a browser or network
    // error, display the localized error message to your customer
    // using `error.message`.
  };
  return (
    <button role="link" onClick={handleClick}>
      Checkout
    </button>
  );
}
ReactDOM.render(<App />, document.getElementById('root'));

This code is typically invoked from an event handler that triggers in response to an action taken by your customer, such as clicking on a payment button.

4 Retrieve the Checkout Session Server-side

After a customer successfully completes their Checkout Session, you need to retrieve the Session object. There are two ways to do this:

  • Asynchronously: Handle checkout.session.completed webhooks, which contain a Session object. Learn more about setting up webhooks.
  • Synchronously: Obtain the sessionId from the URL when a user redirects back to your site (appended to the success_url) and retrieve the Session object.
curl https://api.stripe.com/v1/checkout/sessions/cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc:

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

session = Stripe::Checkout::Session.retrieve('cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k')

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

session = stripe.checkout.Session.retrieve('cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k')

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$session = \Stripe\Checkout\Session::retrieve('cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k');

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

Session session = Stripe.Session.retrieve("cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const session = await stripe.checkout.sessions.retrieve('cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k');

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

session, _ := session.Get("cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k", nil)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var service = new SessionService();
var session = service.Get("cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k");

The right choice depends on your tolerance for dropoff, as customers may not always reach the success_url after a successful payment. It’s possible for them close their browser tab before the redirect occurs. Handling webhooks prevents your integration from being susceptible to this form of dropoff.

After you have retrieved the Session object, get the value of the setup_intent key, which is the ID for the SetupIntent created during the Checkout Session. A SetupIntent is an object used to set up the customer’s bank account information for future payments.

Example checkout.session.completed payload:

{
  "id": "evt_1Ep24XHssDVaQm2PpwS19Yt0",
  "object": "event",
  "api_version": "2019-03-14",
  "created": 1561420781,
  "data": {
    "object": {
      "id": "cs_test_MlZAaTXUMHjWZ7DcXjusJnDU4MxPalbtL5eYrmS2GKxqscDtpJq8QM0k",
      "object": "checkout.session",
      "billing_address_collection": null,
      "cancel_url": "https://example.com/cancel",
      "client_reference_id": null,
      "customer": "cus_FOsk5sbh3ZQpAU",
      "customer_email": null,
      "display_items": [],
      "mode": "setup",
      "setup_intent": "seti_1EzVO3HssDVaQm2PJjXHmLlM",
      "submit_type": null,
      "subscription": null,
      "success_url": "https://example.com/success"
    }
  },
  "livemode": false,
  "pending_webhooks": 1,
  "request": {
    "id": null,
    "idempotency_key": null
  },
  "type": "checkout.session.completed"
}

Note the setup_intent ID for the next step.

5 Retrieve the SetupIntent Server-side

Using the setup_intent ID, retrieve the SetupIntent object.

curl https://api.stripe.com/v1/setup_intents/seti_1EzVO3HssDVaQm2PJjXHmLlM \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc:

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

intent = Stripe::SetupIntent.retrieve('seti_1EzVO3HssDVaQm2PJjXHmLlM')

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

intent = stripe.SetupIntent.retrieve('seti_1EzVO3HssDVaQm2PJjXHmLlM')

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$intent = \Stripe\SetupIntent::retrieve('seti_1EzVO3HssDVaQm2PJjXHmLlM');

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

SetupIntent intent = Stripe.SetupIntent.retrieve("seti_1EzVO3HssDVaQm2PJjXHmLlM");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const intent = await stripe.setupIntents.retrieve('seti_1EzVO3HssDVaQm2PJjXHmLlM');

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

intent, _ := setupintent.Get("seti_1EzVO3HssDVaQm2PJjXHmLlM", nil)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var service = new SetupIntentService();
var intent = service.Get("seti_1EzVO3HssDVaQm2PJjXHmLlM");

Note the payment_method ID returned for the next step.

6 Use the payment method Server-side

If you didn’t create the Checkout Session with an existing customer, attach the PaymentMethod to a Customer. After it has been attached to a Customer, you can charge the PaymentMethod using a PaymentIntent.

The Setup Intents API lets you save a customer’s card without an initial payment. This is helpful if you want to onboard customers now, set them up for payments, and charge them in the future—when they’re offline.

Use this integration to set up recurring payments or to create one-time payments with a final amount determined later, often after the customer receives your service.

1 Set up Stripe Server-side

First, you need a Stripe account. Register now.

Use our official libraries for access to the Stripe API from your application:

# Available as a gem
gem install stripe
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
# Install through pip
pip install --upgrade stripe
# Or find the Stripe package on http://pypi.python.org/pypi/stripe/
# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0
# Install the PHP library via Composer
composer require stripe/stripe-php
# Or download the source directly: https://github.com/stripe/stripe-php/releases
/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"
<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>
# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson
# Install via npm
npm install --save stripe
# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71
// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)
# Install via dotnet
dotnet add package Stripe.net
dotnet restore
# Or install via NuGet
PM> Install-Package Stripe.net

2 Create a Customer before setup Server-side

To set a card up for future payments, it must be attached to a Customer.

You should create a Customer object when your customer creates an account with your business. If your customer is making a payment as a guest, you can create a Customer object before payment and associate it with your own internal representation of the customer’s account later.

Create or retrieve a Customer to associate with these card details. Include the following code on your server to create a new Customer.

curl https://api.stripe.com/v1/customers \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -X POST

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

customer = Stripe::Customer.create

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

customer = stripe.Customer.create()

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$customer = \Stripe\Customer::create();

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

CustomerCreateParams params =
  CustomerCreateParams.builder()
    .build();

Customer customer = Customer.create(params);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const customer = await stripe.customers.create();

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.CustomerParams{}
c, _ := customer.New(params)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var options = new CustomerCreateOptions{};

var service = new CustomerService();
var customer = service.Create(options);

Associate the ID of the Customer object with your own internal representation of a customer, if you have one.

3 Create a SetupIntent Server-side

A SetupIntent is an object that represents your intent to set up a customer’s card for future payments.

The SetupIntent object contains a client secret, a unique key that you need to pass to Stripe.js on the client side to collect card details. The client secret lets you perform certain actions on the client, such as confirming the setup and updating payment method details, while hiding sensitive information like customer. The client secret can be used to validate and authenticate card details via the credit card networks. Because of its sensitive nature, the client secret should not be logged, embedded in URLs, or exposed to anyone other than the customer.

If your application uses server-side rendering, use your template framework to embed the client secret in the page using a data attribute or a hidden HTML element.

curl https://api.stripe.com/v1/setup_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d customer="{{CUSTOMER_ID}}"

<input id="cardholder-name" type="text">
<!-- placeholder for Elements -->
<form id="setup-form" data-secret="<%= @intent.client_secret %>">
  <div id="card-element"></div>
  <button id="card-button">
    Save Card
  </button>
</form>
require 'sinatra'
require 'json'
require 'stripe'

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

get '/card-wallet' do
  @intent = Stripe::SetupIntent.create({
    customer: customer['id'],
  })
  erb :card_wallet
end


<input id="cardholder-name" type="text">
<!-- placeholder for Elements -->
<form id="setup-form" data-secret="{{ client_secret }}">
  <div id="card-element"></div>
  <button id="card-button">
    Save Card
  </button>
</form>
import stripe
import json

from flask import request, render_template

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/card-wallet')
def card_wallet():
  intent = stripe.SetupIntent.create(
    customer=customer['id']
  )
  return render_template('card_wallet.html', client_secret=intent.client_secret)

if __name__ == '__main__':
    app.run()

<?php
  # vendor using composer
  require_once('vendor/autoload.php');

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$intent = \Stripe\SetupIntent::create([
  'customer' => $customer->id
]);
?>
...
<input id="cardholder-name" type="text">
<!-- placeholder for Elements -->
<form id="setup-form" data-secret="<?= $intent->client_secret ?>">
  <div id="card-element"></div>
  <button id="card-button">
    Save Card
  </button>
</form>
...

<input id="cardholder-name" type="text">
<!-- placeholder for Elements -->
<form id="setup-form" data-secret="{{ client_secret }}">
  <div id="card-element"></div>
  <button id="card-button">
    Save Card
  </button>
</form>
import java.util.HashMap;
import java.util.Map;

import com.stripe.Stripe;
import com.stripe.model.SetupIntent;

import spark.ModelAndView;

import static spark.Spark.get;

public class StripeJavaQuickStart {
  public static void main(String[] args) {
    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

    get("/card-wallet", (request, response) -> {
      Map<String, Object> params = new HashMap<>();
      params.put("customer", customer.getId());
      SetupIntent intent = SetupIntent.create(params);

      Map<String, String> map = new HashMap();
      map.put("client_secret", intent.getClientSecret());

      return new ModelAndView(map, "card_wallet.hbs");
    }, new HandlebarsTemplateEngine());
  }
}

<input id="cardholder-name" type="text">
<!-- placeholder for Elements -->
<form id="setup-form" data-secret="{{ client_secret }}">
  <div id="card-element"></div>
  <button id="card-button">
    Save Card
  </button>
</form>
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const express = require('express');
const expressHandlebars = require('express-handlebars');
const app = express();

app.engine('.hbs', expressHandlebars({ extname: '.hbs' }));
app.set('view engine', '.hbs');
app.set('views', './views');

app.get('/card-wallet', async (req, res) => {
  const intent =  await stripe.setupIntents.create({
    customer: customer.id,
  });
  res.render('card_wallet', { client_secret: intent.client_secret });
});

app.listen(3000, () => {
  console.log('Running on port 3000');
});

<input id="cardholder-name" type="text">
<!-- placeholder for Elements -->
<form id="setup-form" data-secret="{{ .ClientSecret }}">
  <div id="card-element"></div>
  <button id="card-button">
    Save Card
  </button>
</form>
package main

import (
  "html/template"
  "net/http"

  stripe "github.com/stripe/stripe-go/v71"
)

type WalletData struct {
  ClientSecret string
}

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

  cardWalletTmpl := template.Must(template.ParseFiles("views/card_wallet.html"))

  http.HandleFunc("/card-wallet", func(w http.ResponseWriter, r *http.Request) {
    params := &stripe.SetupIntentParams{
      Customer: stripe.String(customer.ID),
    }
    intent, err := setupintent.New(params)
    data := WalletData{
      ClientSecret: intent.ClientSecret,
    }
    cardWalletTmpl.Execute(w, data)
  })

  http.ListenAndServe(":3000", nil)
}

<input id="cardholder-name" type="text">
<!-- placeholder for Elements -->
<form id="setup-form" data-secret='@ViewData["ClientSecret"]'>
  <div id="card-element"></div>
  <button id="card-button">
    Save Card
  </button>
</form>
// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

using System;
using Microsoft.AspNetCore.Mvc;
using Stripe;

namespace StripeExampleApi.Controllers
{
    [Route("/card-wallet")]
    public class CardWalletController : Controller
    {
        public IActionResult Index()
        {
          var options = new SetupIntentCreateOptions{
              Customer = "{{CUSTOMER_ID}}",
          };
          var service = new SetupIntentService();
          var intent = service.Create(options);
          ViewData["ClientSecret"] = intent.ClientSecret;
          return View();
        }
    }
}

If you only plan on using the card for future payments when your customer is present during the checkout flow, set the usage parameter to on_session to optimize authorization rates.

4 Collect card details Client-side

The Setup Intents API is fully integrated with Stripe.js, which lets you use the Elements UI library to securely collect card details on the client side.

To get started with Elements, include the following script on your checkout page. Always load Stripe.js directly from js.stripe.com to remain PCI compliant. don’t include the script in a bundle or host a copy of it yourself.

<script src="https://js.stripe.com/v3/"></script>

To best leverage Stripe’s advanced fraud functionality, include this script on every page on your site, not just the checkout page. Including the script on every page allows Stripe to detect suspicious behavior that may be indicative of fraud as users browse your website.

Add Elements to your page

Next, create an instance of the Stripe object, providing your publishable API key as the first parameter. After, create an instance of the Elements object and use it to mount a card element in the DOM.

The card Element simplifies the payment form and minimizes the number of required fields by inserting a single, flexible input field that securely collects all necessary card details.

Otherwise, combine cardNumber, cardExpiry, and cardCvc Elements for a flexible, multi-input card form.

var stripe = Stripe('pk_test_TYooMQauvdEDq54NiTphI7jx');

var elements = stripe.elements();
var cardElement = elements.create('card');
cardElement.mount('#card-element');
const stripe = Stripe('pk_test_TYooMQauvdEDq54NiTphI7jx');

const elements = stripe.elements();
const cardElement = elements.create('card');
cardElement.mount('#card-element');

A Stripe Element contains an iframe that securely sends the payment information to Stripe over a HTTPS connection. The checkout page address must also start with https:// rather than http:// for your integration to work.

You can test your integration without using HTTPS. Enable it when you’re ready to accept live payments.

Confirm the SetupIntent

To complete the setup, retrieve the client secret from the SetupIntent created in the previous step and use stripe.confirmCardSetup and the Card element to complete the setup. When the setup completes successfully, the value of the returned SetupIntent’s status property is succeeded.

var cardholderName = document.getElementById('cardholder-name');
var cardButton = document.getElementById('card-button');
var clientSecret = cardButton.dataset.secret;

cardButton.addEventListener('click', function(ev) {

  stripe.confirmCardSetup(
    clientSecret,
    {
      payment_method: {
        card: cardElement,
        billing_details: {
          name: cardholderName.value,
        },
      },
    }
  ).then(function(result) {
    if (result.error) {
      // Display error.message in your UI.
    } else {
      // The setup has succeeded. Display a success message.
    }
  });
});
const cardholderName = document.getElementById('cardholder-name');
const cardButton = document.getElementById('card-button');
const clientSecret = cardButton.dataset.secret;

cardButton.addEventListener('click', async (ev) => {
  const {setupIntent, error} = await stripe.confirmCardSetup(
    clientSecret,
    {
      payment_method: {
        card: cardElement,
        billing_details: {
          name: cardholderName.value,
        },
      },
    }
  );

  if (error) {
    // Display error.message in your UI.
  } else {
    if (setupIntent.status === 'succeeded') {
      // The setup has succeeded. Display a success message. Send
      // setupIntent.payment_method to your server to save the card to a Customer
    }
  }
});

Install React Stripe.js and the Stripe.js loader from the npm public registry.

npm install --save @stripe/react-stripe-js @stripe/stripe-js

We also provide a UMD build for sites that do not use npm or modules.

Include the Stripe.js script, which exports a global Stripe function, and the UMD build of React Stripe.js, which exports a global ReactStripe object. Always load the Stripe.js script directly from js.stripe.com to remain PCI compliant. Do not include the script in a bundle or host a copy of it yourself.

<!-- Stripe.js -->
<script src="https://js.stripe.com/v3/"></script>

<!-- React Stripe.js development build -->
<script src="https://unpkg.com/@stripe/react-stripe-js@latest/dist/react-stripe.umd.js"></script>

<!-- When you are ready to deploy your site to production, remove the
     above development script, and include the following production build. -->
<script src="https://unpkg.com/@stripe/react-stripe-js@latest/dist/react-stripe.umd.min.js"></script>

Add Stripe.js and Elements to your page

To use Element components, wrap the root of your React app in an Elements provider. Call loadStripe with your publishable key and pass the returned Promise to the Elements provider.

import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CardSetupForm from './CardSetupForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe("pk_test_TYooMQauvdEDq54NiTphI7jx");

function App() {
  return (
    <Elements stripe={stripePromise}>
      <CardSetupForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));

Add and configure a CardElement component

Use individual Element components, such as CardElement, to build your form.

/**
* Use the CSS tab above to style your Element's container.
*/
import React from 'react';
import {CardElement} from '@stripe/react-stripe-js';
import './CardSectionStyles.css'

const CARD_ELEMENT_OPTIONS = {
  style: {
    base: {
      color: "#32325d",
      fontFamily: '"Helvetica Neue", Helvetica, sans-serif',
      fontSmoothing: "antialiased",
      fontSize: "16px",
      "::placeholder": {
        color: "#aab7c4",
      },
    },
    invalid: {
      color: "#fa755a",
      iconColor: "#fa755a",
    },
  },
};

function CardSection() {
  return (
    <label>
      Card details
      <CardElement options={CARD_ELEMENT_OPTIONS} />
    </label>
  );
};

export default CardSection;

/**
* Shows how you can use CSS to style your Element's container.
* These classes are added to your Stripe Element by default.
* You can override these classNames by using the options passed
* to the CardElement component.
* https://stripe.com/docs/js/elements_object/create_element?type=card#elements_create-options-classes
*/

.StripeElement {
  height: 40px;
  padding: 10px 12px;
  width: 100%;
  color: #32325d;
  background-color: white;
  border: 1px solid transparent;
  border-radius: 4px;

  box-shadow: 0 1px 3px 0 #e6ebf1;
  -webkit-transition: box-shadow 150ms ease;
  transition: box-shadow 150ms ease;
}

.StripeElement--focus {
  box-shadow: 0 1px 3px 0 #cfd7df;
}

.StripeElement--invalid {
  border-color: #fa755a;
}

.StripeElement--webkit-autofill {
  background-color: #fefde5 !important;
}

Elements are completely customizable. You can style Elements to match the look and feel of your site, providing a seamless checkout experience for your customers. It’s also possible to style various input states, for example when the Element has focus.

The CardElement simplifies the form and minimizes the number of required fields by inserting a single, flexible input field that securely collects all necessary card and billing details. Otherwise, combine CardNumberElement, CardExpiryElement, and CardCvcElement elements for a flexible, multi-input card form.

Confirm the SetupIntent

To complete the setup, retrieve the client secret from the SetupIntent created in step three and use stripe.confirmCardSetup and the Card element to complete the setup. When the setup completes successfully, the value of the returned SetupIntent’s status property is succeeded.

To call stripe.confirmCardSetup from your payment form component, use the useStripe and useElements hooks. If you prefer traditional class components over hooks, you can instead use an ElementsConsumer.

import React from 'react';
import {useStripe, useElements, CardElement} from '@stripe/react-stripe-js';

import CardSection from './CardSection';

export default function CardSetupForm() {
  const stripe = useStripe();
  const elements = useElements();

  const handleSubmit = async (event) => {
    // We don't want to let default form submission happen here,
    // which would refresh the page.
    event.preventDefault();

    if (!stripe || !elements) {
      // Stripe.js has not yet loaded.
      // Make sure to disable form submission until Stripe.js has loaded.
      return;
    }

    const result = await stripe.confirmCardSetup('{{CLIENT_SECRET}}', {
      payment_method: {
        card: elements.getElement(CardElement),
        billing_details: {
          name: 'Jenny Rosen',
        },
      }
    });

    if (result.error) {
      // Display result.error.message in your UI.
    } else {
      // The setup has succeeded. Display a success message and send
      // result.setupIntent.payment_method to your server to save the
      // card to a Customer
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <CardSection />
      <button disabled={!stripe}>Save Card</button>
    </form>
  );
}

import React from 'react';
import {ElementsConsumer, CardElement} from '@stripe/react-stripe-js';

import CardSection from './CardSection';

class CardSetupForm extends React.Component {
  handleSubmit = async (event) => {
    // We don't want to let default form submission happen here,
    // which would refresh the page.
    event.preventDefault();

    const {stripe, elements} = this.props

    if (!stripe || !elements) {
      // Stripe.js has not yet loaded.
      // Make  sure to disable form submission until Stripe.js has loaded.
      return;
    }

    const result = await stripe.confirmCardSetup('{{CLIENT_SECRET}}', {
      payment_method: {
        card: elements.getElement(CardElement),
        billing_details: {
          name: 'Jenny Rosen',
        },
      }
    });

    if (result.error) {
      // Display result.error.message in your UI.
    } else {
      // The setup has succeeded. Display a success message and send
      // result.setupIntent.payment_method to your server to save the
      // card to a Customer
    }
  };

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <CardSection />
        <button disabled={!this.props.stripe}>Save Card</button>
      </form>
    );
  }
}

export default function InjectedCardSetupForm() {
  return (
    <ElementsConsumer>
      {({stripe, elements}) => (
        <CardSetupForm  stripe={stripe} elements={elements} />
      )}
    </ElementsConsumer>
  );
}

The SetupIntent verifies that the card information your customer is using is valid on the network. However, automatic verification isn’t always performed. For details on this, see Check if a card is valid without a charge. Also, don’t maintain long-lived, unhandled SetupIntents as they may no longer be valid when you call stripe.confirmCardSetup.

You now have a flow to collect card details and handle any authentication requests. Use the test card 4000 0025 0000 3155, along with any CVC, postal code, and future expiration date to test the authentication process.

When saving cards to charge later, it’s important to get customer permission up front. Add text in your checkout flow that references the terms of the payment, for example:

When the SetupIntent succeeds, the resulting PaymentMethod ID (in result.setupIntent.payment_method) will be saved to the provided Customer.

5 Charge the saved card later Server-side

When you are ready to charge your customer off-session, use the Customer and PaymentMethod IDs to create a PaymentIntent.

To find a card to charge, list the PaymentMethods associated with your Customer.

curl https://api.stripe.com/v1/payment_methods \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d customer="{{CUSTOMER_ID}}" \
  -d type=card \
  -G

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

Stripe::PaymentMethod.list({
  customer: '{{CUSTOMER_ID}}',
  type: 'card',
})

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

stripe.PaymentMethod.list(
  customer="{{CUSTOMER_ID}}",
  type="card",
)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

\Stripe\PaymentMethod::all([
  'customer' => '{{CUSTOMER_ID}}',
  'type' => 'card',
]);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

PaymentMethodListParams params =
  PaymentMethodListParams.builder()
    .setCustomer("{{CUSTOMER_ID}}")
    .setType(PaymentMethodListParams.Type.CARD)
    .build();

PaymentMethodCollection paymentMethods = PaymentMethod.list(params);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const paymentMethods = await stripe.paymentMethods.list({
  customer: '{{CUSTOMER_ID}}',
  type: 'card',
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentMethodListParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  Type: stripe.String(string(stripe.PaymentMethodTypeCard)),
}
i := paymentmethod.List(params)
for i.Next() {
  pm := i.PaymentMethod()
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var options = new PaymentMethodListOptions
{
  Customer = "{{CUSTOMER_ID}}",
  Type = "card",
};

var service = new PaymentMethodService();
var paymentMethods = service.List(options);

When you have the Customer and PaymentMethod IDs, create a PaymentIntent with the amount and currency of the payment. Set a few other parameters to make the off-session payment:

  • Set off_session to true to indicate that the customer is not in your checkout flow during this payment attempt. This causes the PaymentIntent to throw an error if authentication is required.
  • Set the value of the PaymentIntent’s confirm property to true, which causes confirmation to occur immediately when the PaymentIntent is created.
  • Set payment_method to the ID of the PaymentMethod and customer to the ID of the Customer.
curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d amount=1099 \
  -d currency=usd \
  -d customer="{{CUSTOMER_ID}}" \
  -d payment_method="{{PAYMENT_METHOD_ID}}" \
  -d off_session=true \
  -d confirm=true

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

begin
  intent = Stripe::PaymentIntent.create({
    amount: 1099,
    currency: 'usd',
    customer: '{{CUSTOMER_ID}}',
    payment_method: '{{PAYMENT_METHOD_ID}}',
    off_session: true,
    confirm: true,
  })
rescue Stripe::CardError => e
  # Error code will be authentication_required if authentication is needed
  puts "Error is: #{e.error.code}"
  payment_intent_id = e.error.payment_intent.id
  payment_intent = Stripe::PaymentIntent.retrieve(payment_intent_id)
  puts payment_intent.id
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

try:
  stripe.PaymentIntent.create(
    amount=1099,
    currency='usd',
    customer='{{CUSTOMER_ID}}',
    payment_method='{{PAYMENT_METHOD_ID}}',
    off_session=True,
    confirm=True,
  )
except stripe.error.CardError as e:
  err = e.error
  # Error code will be authentication_required if authentication is needed
  print("Code is: %s" % err.code)
  payment_intent_id = err.payment_intent['id']
  payment_intent = stripe.PaymentIntent.retrieve(payment_intent_id)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

try {
  \Stripe\PaymentIntent::create([
    'amount' => 1099,
    'currency' => 'usd',
    'customer' => '{{CUSTOMER_ID}}',
    'payment_method' => '{{PAYMENT_METHOD_ID}}',
    'off_session' => true,
    'confirm' => true,
  ]);
} catch (\Stripe\Exception\CardException $e) {
  // Error code will be authentication_required if authentication is needed
  echo 'Error code is:' . $e->getError()->code;
  $payment_intent_id = $e->getError()->payment_intent->id;
  $payment_intent = \Stripe\PaymentIntent::retrieve($payment_intent_id);
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder()
    .setCurrency("usd")
    .setAmount(1099)
    .setPaymentMethod("{{PAYMENT_METHOD_ID}}")
    .setCustomer("{{CUSTOMER_ID}}")
    .setConfirm(true)
    .setOffSession(true)
    .build();
try {
  PaymentIntent.create(params);
} catch (CardException err) {
  // Error code will be authentication_required if authentication is needed
  System.out.println("Error code is : " + e.getCode());
  String paymentIntentId = e.getStripeError().getPaymentIntent().getId();
  PaymentIntent paymentIntent = PaymentIntent.retrieve(paymentIntentId);
  System.out.println(paymentIntent.getId());
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

try {
  const paymentIntent = await stripe.paymentIntents.create({
    amount: 1099,
    currency: 'usd',
    customer: '{{CUSTOMER_ID}}',
    payment_method: '{{PAYMENT_METHOD_ID}}',
    off_session: true,
    confirm: true,
  });
} catch (err) {
  // Error code will be authentication_required if authentication is needed
  console.log('Error code is: ', err.code);
  const paymentIntentRetrieved = await stripe.paymentIntents.retrieve(err.raw.payment_intent.id);
  console.log('PI retrieved: ', paymentIntentRetrieved.id);
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(1099),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  PaymentMethod: stripe.String("{{PAYMENT_METHOD_ID}}"),
  Confirm: stripe.Bool(true),
  OffSession: stripe.Bool(true),
}

_, err := paymentintent.New(params)

if err != nil {
  if stripeErr, ok := err.(*stripe.Error); ok {
    // Error code will be authentication_required if authentication is needed
    fmt.Printf("Error code: %v", stripeErr.Code)

    paymentIntentID := stripeErr.PaymentIntent.ID
    paymentIntent, _ := paymentintent.Get(paymentIntentID, nil)

    fmt.Printf("PI: %v", paymentIntent.ID)
  }
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

try
{
  var service = new PaymentIntentService();
  var options = new PaymentIntentCreateOptions
  {
    Amount = 1099,
    Currency = "usd",
    Customer = "{{CUSTOMER_ID}}",
    PaymentMethod = "{{PAYMENT_METHOD_ID}}",
    Confirm = true,
    OffSession = true,
  };
  service.Create(options);
}
catch (StripeException e)
{
  switch (e.StripeError.ErrorType)
  {
    case "card_error":
      // Error code will be authentication_required if authentication is needed
      Console.WriteLine("Error code: " + e.StripeError.Code);
      var paymentIntentId = e.StripeError.PaymentIntent.Id;
      var service = new PaymentIntentService();
      var paymentIntent = service.Get(paymentIntentId);

      Console.WriteLine(paymentIntent.Id);
      break;
    default:
      break;
  }
}

When a payment attempt fails, the request also fails with a 402 HTTP status code and the status of the PaymentIntent is requires_payment_method. You need to notify your customer to return to your application (e.g., by sending an email or in-app notification) to complete the payment. Check the code of the Error raised by the Stripe API library or check the last_payment_error.decline_code on the PaymentIntent to inspect why the card issuer declined the payment.

If the payment failed due to an authentication_required decline code, use the declined PaymentIntent’s client secret and payment method with confirmCardPayment to allow the customer to authenticate the payment.

// Pass the failed PaymentIntent to your client from your server
stripe.confirmCardPayment(intent.client_secret, {
  payment_method: intent.last_payment_error.payment_method.id
}).then(function(result) {
  if (result.error) {
    // Show error to your customer
    console.log(result.error.message);
  } else {
    if (result.paymentIntent.status === 'succeeded') {
      // The payment is complete!
    }
  }
});

If the payment failed for other reasons, such as insufficient funds on the card, send your customer to a payment page to enter a new card. You can reuse the existing PaymentIntent to attempt the payment again with the new card details.

6 Test the integration

By this point you should have an integration that:

  1. Collects and saves card details without charging the customer by using a SetupIntent
  2. Charges the card off-session and has a recovery flow to handle declines and authentication requests

There are several test cards you can use to make sure this integration is ready for production. Use them with any CVC, postal code, and future expiration date.

Number Description
4242424242424242 Succeeds and immediately processes the payment.
4000002500003155 Requires authentication for the initial purchase, but succeeds for subsequent payments (including off-session ones) as long as the card is setup with setup_future_usage.
4000002760003184 Requires authentication for the initial purchase, and fails for subsequent payments (including off-session ones) with an authentication_required decline code.
4000008260003178 Requires authentication for the initial purchase, but fails for subsequent payments (including off-session ones) with an insufficient_funds decline code.
4000000000009995 Always fails (including the initial purchase) with a decline code of insufficient_funds.

For the full list of test cards see our guide on testing.

The Setup Intents API lets you save a customer’s card without an initial payment. This is helpful if you want to onboard customers now, set them up for payments, and charge them in the future—when they’re offline.

Use this integration to set up recurring payments or to create one-time payments with a final amount determined later, often after the customer receives your service.

1 Set up Stripe Client-side Server-side

First, you need a Stripe account. Register now.

Server-side

This integration requires endpoints on your server that talk to the Stripe API. Use our official libraries for access to the Stripe API from your server:

# Available as a gem
gem install stripe
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
# Install through pip
pip install --upgrade stripe
# Or find the Stripe package on http://pypi.python.org/pypi/stripe/
# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0
# Install the PHP library via Composer
composer require stripe/stripe-php
# Or download the source directly: https://github.com/stripe/stripe-php/releases
/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"
<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>
# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson
# Install via npm
npm install --save stripe
# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71
// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)
# Install via dotnet
dotnet add package Stripe.net
dotnet restore
# Or install via NuGet
PM> Install-Package Stripe.net

Client-side

The iOS SDK is open source, fully documented, and compatible with apps supporting iOS 10 or above.

  1. If you haven't already, install the latest version of CocoaPods.
  2. If you don't have an existing Podfile, run the following command to create one: 
    pod init
  3. Add this line to your Podfile: 
    pod 'Stripe'
  4. Run the following command: 
    pod install
  5. Don't forget to use the .xcworkspace file to open your project in Xcode, instead of the .xcodeproj file, from here on out.
  6. In the future, to update to the latest version of the SDK, just run: 
    pod update Stripe
  1. If you haven't already, install the latest version of Carthage.
  2. Add this line to your Cartfile: 
    github "stripe/stripe-ios"
  3. Follow the Carthage installation instructions.
  4. In the future, to update to the latest version of the SDK, run the following command: 
    carthage update stripe-ios --platform ios
  1. Head to our GitHub releases page and download and unzip Stripe.framework.zip.
  2. Drag Stripe.framework to the "Embedded Binaries" section of your Xcode project's "General" settings. Make sure to select "Copy items if needed".
  3. Head to the "Build Phases" section of your Xcode project settings, and create a new "Run Script Build Phase". Paste the following snippet into the text field: 
    bash "${BUILT_PRODUCTS_DIR}/${FRAMEWORKS_FOLDER_PATH}/Stripe.framework/integrate-dynamic-framework.sh"
  4. In the future, to update to the latest version of our SDK, just repeat steps 1 and 2.

When your app starts, configure the SDK with your Stripe publishable key so that it can make requests to the Stripe API.

import UIKit
import Stripe

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        Stripe.setDefaultPublishableKey("pk_test_TYooMQauvdEDq54NiTphI7jx")
        // do any other necessary launch configuration
        return true
    }
}
#import "AppDelegate.h"
#import <Stripe/Stripe.h>

@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [Stripe setDefaultPublishableKey:@"pk_test_TYooMQauvdEDq54NiTphI7jx"];
    // do any other necessary launch configuration
    return YES;
}
@end

2 Create a Customer before setup Server-side

To set a card up for future payments, it must be attached to a Customer.

You should create a Customer object when your customer creates an account with your business. If your customer is making a payment as a guest, you can create a Customer object before payment and associate it with your own internal representation of the customer’s account later.

Create or retrieve a Customer to associate with these card details. Include the following code on your server to create a new Customer.

curl https://api.stripe.com/v1/customers \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -X POST

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

customer = Stripe::Customer.create

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

customer = stripe.Customer.create()

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$customer = \Stripe\Customer::create();

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

CustomerCreateParams params =
  CustomerCreateParams.builder()
    .build();

Customer customer = Customer.create(params);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const customer = await stripe.customers.create();

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.CustomerParams{}
c, _ := customer.New(params)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var options = new CustomerCreateOptions{};

var service = new CustomerService();
var customer = service.Create(options);

Associate the ID of the Customer object with your own internal representation of a customer, if you have one.

3 Create a SetupIntent Server-side

A SetupIntent is an object that represents your intent to set up a payment method for future payments.

The SetupIntent object contains a client secret, a unique key that you pass to your app. The client secret lets you perform certain actions on the client, such as confirming the setup and updating payment method details, while hiding sensitive information like customer. The client secret can be used to validate and authenticate card details via the credit card networks. Because of its sensitive nature, the client secret should not be logged, embedded in URLs, or exposed to anyone other than the customer.

Server-side

On your server, make an endpoint that creates a SetupIntent and returns its client secret to your app.

curl https://api.stripe.com/v1/setup_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d customer="{{CUSTOMER_ID}}"

require 'sinatra'
require 'json'
require 'stripe'

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

get '/card-wallet' do
  setup_intent = Stripe::SetupIntent.create({
    customer: customer['id'],
  })
  client_secret = setup_intent['client_secret']
  # Pass the client secret to the client
end

import stripe
import json

from flask import request, render_template

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/card-wallet')
def card_wallet():
  setup_intent = stripe.SetupIntent.create(
    customer=customer['id']
  )
  client_secret = setup_intent.client_secret
  # Pass the client secret to the client

if __name__ == '__main__':
    app.run()


// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

# vendor using composer
require_once('vendor/autoload.php');

$setup_intent = \Stripe\SetupIntent::create([
  'customer' => $customer->id
]);
$client_secret = $setup_intent->client_secret
// Pass the client secret to the client

import java.util.HashMap;
import java.util.Map;

import com.stripe.Stripe;
import com.stripe.model.SetupIntent;

public class StripeJavaQuickStart {
  public static void main(String[] args) {
    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

    Map<String, Object> params = new HashMap<>();
    params.put("customer", customer.getId());
    SetupIntent setupIntent = SetupIntent.create(params);
    String clientSecret = setupIntent.getClientSecret();
    // Pass the client secret to the client
  }
}

// Using Express
const express = require('express');
const app = express();
app.use(express.json());
const { resolve } = require("path");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const setupIntent = await stripe.setupIntents.create({
  customer: customer.id,
});
const clientSecret = setupIntent.client_secret;
// Pass the client secret to the client

package main

import (
  "encoding/json"
  "log"
  "net/http"

  "github.com/stripe/stripe-go/v71"
  "github.com/stripe/stripe-go/v71/setupintent"
)

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"
  params := &stripe.SetupIntentParams{
    Customer: stripe.String(customer.ID),
  }
  si, _ := setupintent.New(params)
  clientSecret := si.ClientSecret
  // Pass the client secret to the client
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

using System;
using Microsoft.AspNetCore.Mvc;
using Stripe;

namespace StripeExampleApi.Controllers
{
    [Route("/card-wallet")]
    public class CardWalletController : Controller
    {
        public IActionResult Index()
        {
          var options = new SetupIntentCreateOptions{
              Customer = "{{CUSTOMER_ID}}",
          };
          var service = new SetupIntentService();
          SetupIntent setupIntent = service.Create(options);
          var clientSecret = setupIntent.ClientSecret;
          // Pass the client secret to the client
        }
    }
}

If you only plan on using the card for future payments when your customer is present during the checkout flow, set the usage parameter to on_session to optimize authorization rates.

Client-side

On the client, request a SetupIntent from your server.

import Stripe

class CheckoutViewController: UIViewController {
    var setupIntentClientSecret: String?

    func startCheckout() {
        // Request a SetupIntent from your server and store its client secret
        // Click Open on GitHub to see a full implementation
    }
}
#import "CheckoutViewController.h"
#import <Stripe/Stripe.h>

@interface CheckoutViewController ()  <STPAuthenticationContext>
@property (nonatomic, copy) NSString *setupIntentClientSecret;
@end

@implementation CheckoutViewController

- (void)startCheckout {
    // Request a SetupIntent from your server and store its client secret
    // Click Open on GitHub to see a full implementation
}

@end

4 Collect card details Client-side

When the customer submits the payment form, collect card details from the customer using STPPaymentCardTextField, a drop-in UI component provided by the SDK.

STPPaymentCardTextField performs on-the-fly validation and formatting.

Pass the collected information into new STPPaymentMethodCardParams and STPPaymentMethodBillingDetails instances to create an STPSetupIntentConfirmParams instance.

class CheckoutViewController: UIViewController {
    lazy var cardTextField: STPPaymentCardTextField = {
        let cardTextField = STPPaymentCardTextField()
        return cardTextField
    }()

    func pay() {
        // Collect card details
        let cardParams = cardTextField.cardParams
        // Fill in any billing details...
        let billingDetails = STPPaymentMethodBillingDetails()

        // Create SetupIntent confirm parameters with the above
        let paymentMethodParams = STPPaymentMethodParams(card: cardParams, billingDetails: billingDetails, metadata: nil)
        let setupIntentParams = STPSetupIntentConfirmParams(clientSecret: setupIntentClientSecret)
        setupIntentParams.paymentMethodParams = paymentMethodParams

        // ...continued in next step
    }
}

@interface CheckoutViewController ()
@property (nonatomic, weak) STPPaymentCardTextField *cardTextField;
@end

@implementation CheckoutViewController

- (void)pay {
    // Collect card details
    STPPaymentMethodCardParams *cardParams = self.cardTextField.cardParams;
    // Fill in any billing details...
    STPPaymentMethodBillingDetails *billingDetails = [STPPaymentMethodBillingDetails new];

    // Create SetupIntent confirm parameters with the above
    STPPaymentMethodParams *paymentMethodParams = [STPPaymentMethodParams paramsWithCard:cardParams billingDetails:billingDetails metadata:nil];
    STPSetupIntentConfirmParams *setupIntentParams = [[STPSetupIntentConfirmParams alloc] initWithClientSecret:self.setupIntentClientSecret];
    setupIntentParams.paymentMethodParams = paymentMethodParams;

    // ...continued in next step
}

@end

To complete the setup, pass the STPSetupIntentConfirmParams object to the confirmSetupIntent method on STPPaymentHandler sharedManager.

If the customer must perform additional steps to complete the payment, such as authentication, STPPaymentHandler presents view controllers using the STPAuthenticationContext passed in and walks them through that process. See Supporting 3D Secure Authentication on iOS to learn more.

class CheckoutViewController: UIViewController {
    // ...

    func pay() {
        // ...

        // Complete the setup
        let paymentHandler = STPPaymentHandler.shared()
        paymentHandler.confirmSetupIntent(withParams: setupIntentParams, authenticationContext: self) { status, setupIntent, error in
            switch (status) {
            case .failed:
                // Setup failed
                break
            case .canceled:
                // Setup canceled
                break
            case .succeeded:
                // Setup succeeded
                break
            @unknown default:
                fatalError()
                break
            }
        }
    }
}

extension CheckoutViewController: STPAuthenticationContext {
    func authenticationPresentingViewController() -> UIViewController {
        return self
    }
}


@interface CheckoutViewController ()  <STPAuthenticationContext>
@end

@implementation CheckoutViewController

- (void)pay {
    // ...
    STPPaymentHandler *paymentHandler = [STPPaymentHandler sharedHandler];
    [paymentHandler confirmSetupIntent:setupIntentParams withAuthenticationContext:self completion:^(STPPaymentHandlerActionStatus status, STPSetupIntent *setupIntent, NSError *error) {
        switch (status) {
            case STPPaymentHandlerActionStatusFailed: {
                // Setup failed
                break;
            }
            case STPPaymentHandlerActionStatusCanceled: {
                // Setup canceled
                break;
            }
            case STPPaymentHandlerActionStatusSucceeded: {
                // Setup succeeded
                break;
            }
            default:
                break;
        }
    }];
}

# pragma mark STPAuthenticationContext
- (UIViewController *)authenticationPresentingViewController {
    return self;
}

The SetupIntent verifies that the card information your customer is using is valid on the network. However, automatic verification isn’t always performed. For details on this, see Check if a card is valid without a charge. Also, don’t maintain long-lived, unhandled SetupIntents as they may no longer be valid when you call confirmSetupIntent.

You now have a flow to collect card details and handle any authentication requests. Use the test card 4000 0025 0000 3155, along with any CVC, postal code, and future expiration date to test the authentication process.

When the SetupIntent succeeds, the resulting PaymentMethod ID (in setupIntent.paymentMethodID) will be saved to the provided Customer.

5 Charge the saved card later Server-side

When you are ready to charge your customer off-session, use the Customer and PaymentMethod IDs to create a PaymentIntent.

To find a card to charge, list the PaymentMethods associated with your Customer.

curl https://api.stripe.com/v1/payment_methods \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d customer="{{CUSTOMER_ID}}" \
  -d type=card \
  -G

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

Stripe::PaymentMethod.list({
  customer: '{{CUSTOMER_ID}}',
  type: 'card',
})

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

stripe.PaymentMethod.list(
  customer="{{CUSTOMER_ID}}",
  type="card",
)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

\Stripe\PaymentMethod::all([
  'customer' => '{{CUSTOMER_ID}}',
  'type' => 'card',
]);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

PaymentMethodListParams params =
  PaymentMethodListParams.builder()
    .setCustomer("{{CUSTOMER_ID}}")
    .setType(PaymentMethodListParams.Type.CARD)
    .build();

PaymentMethodCollection paymentMethods = PaymentMethod.list(params);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const paymentMethods = await stripe.paymentMethods.list({
  customer: '{{CUSTOMER_ID}}',
  type: 'card',
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentMethodListParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  Type: stripe.String(string(stripe.PaymentMethodTypeCard)),
}
i := paymentmethod.List(params)
for i.Next() {
  pm := i.PaymentMethod()
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var options = new PaymentMethodListOptions
{
  Customer = "{{CUSTOMER_ID}}",
  Type = "card",
};

var service = new PaymentMethodService();
var paymentMethods = service.List(options);

When you have the Customer and PaymentMethod IDs, create a PaymentIntent with the amount and currency of the payment. Set a few other parameters to make the off-session payment:

  • Set off_session to true to indicate that the customer is not in your checkout flow during this payment attempt. This causes the PaymentIntent to throw an error if authentication is required.
  • Set the value of the PaymentIntent’s confirm property to true, which causes confirmation to occur immediately when the PaymentIntent is created.
  • Set payment_method to the ID of the PaymentMethod and customer to the ID of the Customer.
curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d amount=1099 \
  -d currency=usd \
  -d customer="{{CUSTOMER_ID}}" \
  -d payment_method="{{PAYMENT_METHOD_ID}}" \
  -d off_session=true \
  -d confirm=true

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

begin
  intent = Stripe::PaymentIntent.create({
    amount: 1099,
    currency: 'usd',
    customer: '{{CUSTOMER_ID}}',
    payment_method: '{{PAYMENT_METHOD_ID}}',
    off_session: true,
    confirm: true,
  })
rescue Stripe::CardError => e
  # Error code will be authentication_required if authentication is needed
  puts "Error is: #{e.error.code}"
  payment_intent_id = e.error.payment_intent.id
  payment_intent = Stripe::PaymentIntent.retrieve(payment_intent_id)
  puts payment_intent.id
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

try:
  stripe.PaymentIntent.create(
    amount=1099,
    currency='usd',
    customer='{{CUSTOMER_ID}}',
    payment_method='{{PAYMENT_METHOD_ID}}',
    off_session=True,
    confirm=True,
  )
except stripe.error.CardError as e:
  err = e.error
  # Error code will be authentication_required if authentication is needed
  print("Code is: %s" % err.code)
  payment_intent_id = err.payment_intent['id']
  payment_intent = stripe.PaymentIntent.retrieve(payment_intent_id)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

try {
  \Stripe\PaymentIntent::create([
    'amount' => 1099,
    'currency' => 'usd',
    'customer' => '{{CUSTOMER_ID}}',
    'payment_method' => '{{PAYMENT_METHOD_ID}}',
    'off_session' => true,
    'confirm' => true,
  ]);
} catch (\Stripe\Exception\CardException $e) {
  // Error code will be authentication_required if authentication is needed
  echo 'Error code is:' . $e->getError()->code;
  $payment_intent_id = $e->getError()->payment_intent->id;
  $payment_intent = \Stripe\PaymentIntent::retrieve($payment_intent_id);
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder()
    .setCurrency("usd")
    .setAmount(1099)
    .setPaymentMethod("{{PAYMENT_METHOD_ID}}")
    .setCustomer("{{CUSTOMER_ID}}")
    .setConfirm(true)
    .setOffSession(true)
    .build();
try {
  PaymentIntent.create(params);
} catch (CardException err) {
  // Error code will be authentication_required if authentication is needed
  System.out.println("Error code is : " + e.getCode());
  String paymentIntentId = e.getStripeError().getPaymentIntent().getId();
  PaymentIntent paymentIntent = PaymentIntent.retrieve(paymentIntentId);
  System.out.println(paymentIntent.getId());
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

try {
  const paymentIntent = await stripe.paymentIntents.create({
    amount: 1099,
    currency: 'usd',
    customer: '{{CUSTOMER_ID}}',
    payment_method: '{{PAYMENT_METHOD_ID}}',
    off_session: true,
    confirm: true,
  });
} catch (err) {
  // Error code will be authentication_required if authentication is needed
  console.log('Error code is: ', err.code);
  const paymentIntentRetrieved = await stripe.paymentIntents.retrieve(err.raw.payment_intent.id);
  console.log('PI retrieved: ', paymentIntentRetrieved.id);
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(1099),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  PaymentMethod: stripe.String("{{PAYMENT_METHOD_ID}}"),
  Confirm: stripe.Bool(true),
  OffSession: stripe.Bool(true),
}

_, err := paymentintent.New(params)

if err != nil {
  if stripeErr, ok := err.(*stripe.Error); ok {
    // Error code will be authentication_required if authentication is needed
    fmt.Printf("Error code: %v", stripeErr.Code)

    paymentIntentID := stripeErr.PaymentIntent.ID
    paymentIntent, _ := paymentintent.Get(paymentIntentID, nil)

    fmt.Printf("PI: %v", paymentIntent.ID)
  }
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

try
{
  var service = new PaymentIntentService();
  var options = new PaymentIntentCreateOptions
  {
    Amount = 1099,
    Currency = "usd",
    Customer = "{{CUSTOMER_ID}}",
    PaymentMethod = "{{PAYMENT_METHOD_ID}}",
    Confirm = true,
    OffSession = true,
  };
  service.Create(options);
}
catch (StripeException e)
{
  switch (e.StripeError.ErrorType)
  {
    case "card_error":
      // Error code will be authentication_required if authentication is needed
      Console.WriteLine("Error code: " + e.StripeError.Code);
      var paymentIntentId = e.StripeError.PaymentIntent.Id;
      var service = new PaymentIntentService();
      var paymentIntent = service.Get(paymentIntentId);

      Console.WriteLine(paymentIntent.Id);
      break;
    default:
      break;
  }
}

Inspect the status property of the PaymentIntent to confirm that the payment completed successfully. If the payment attempt succeeded, the PaymentIntent’s status is succeeded and the off-session payment is complete.

Start a recovery flow

If the PaymentIntent has any other status, the payment did not succeed and the request fails. Notify your customer to return to your application (e.g., by email, text, push notification) to complete the payment. We recommend creating a recovery flow in your app that shows why the payment failed initially and lets your customer retry.

In your recovery flow, retrieve the PaymentIntent via its client secret. Check the PaymentIntent’s lastPaymentError to inspect why the payment attempt failed. For card errors, you can show the user the last payment error’s message. Otherwise, you can show a generic failure message.

func startRecoveryFlow(clientSecret: String) {
    // Retrieve the PaymentIntent
    STPAPIClient.shared().retrievePaymentIntent(withClientSecret: clientSecret) { (paymentIntent, error) in
        guard error == nil, let lastPaymentError = paymentIntent?.lastPaymentError else {
            // Handle error (e.g. allow your customer to retry)
            return
        }
        var failureReason = "Payment failed, try again." // Default to a generic error message
        if lastPaymentError.type == .card {
            failureReason = lastPaymentError.message
        }
        // Display the failure reason to your customer
        // ...
    }
}

- (void)startRecoveryFlow:(NSString *)clientSecret {
    // Retrieve the PaymentIntent
    [[STPAPIClient sharedClient] retrievePaymentIntentWithClientSecret:clientSecret completion:^(STPPaymentIntent * _Nullable paymentIntent, NSError * _Nullable error) {
        if (error || paymentIntent.status == STPPaymentIntentStatusSucceeded) {
            // Handle error (e.g. allow your customer to retry)
            return;
        }
        NSString *failureReason = @"Payment failed, try again."; // Default to a generic error message
        if (paymentIntent.lastPaymentError.type == STPPaymentIntentLastPaymentErrorTypeCard) {
            // For card errors, the error's message can be shown to your customer
            failureReason = paymentIntent.lastPaymentError.message;
        }
        // Display the failure reason to your customer
        // ...
    }];
}

Let your customer try again

Give the customer the option to update or remove their saved card and try payment again in your recovery flow. Follow the same steps you did to accept their initial payment with one difference—confirm the original, failed PaymentIntent by reusing its client secret instead of creating a new one.

If the payment failed because it requires authentication, try again with the existing PaymentMethod instead of creating a new one.

func startRecoveryFlow(clientSecret: String) {
    // ...continued from previous step
    // Reuse the existing PaymentIntent's client secret
    let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret)
    if paymentIntent.lastPaymentError.code == STPPaymentIntentLastPaymentErrorCodeAuthenticationFailure {
        // Payment failed because authentication is required, reuse the PaymentMethod
        paymentIntentParams.paymentMethodId = paymentIntent.lastPaymentError.paymentMethod.stripeId
    } else {
        // Collect a new PaymentMethod from the customer...
    }

    // Submit the payment...
}

- (void)startRecoveryFlow:(NSString *)clientSecret {
    // ...continued from previous step
    // Reuse the existing PaymentIntent's client secret
    STPPaymentIntentParams *paymentIntentParams = [STPPaymentIntentParams alloc] initWithClientSecret:clientSecret]
    if ([paymentIntent.lastPaymentError.code isEqualToString:STPPaymentIntentLastPaymentErrorCodeAuthenticationFailure]) {
        // Payment failed because authentication is required, reuse the PaymentMethod
        paymentIntentParams.paymentMethodId = paymentIntent.lastPaymentError.paymentMethod.stripeId;
    } else {
        // Collect a new PaymentMethod from the customer...
    }

    // Submit the payment...
}

6 Test the integration

By this point you should have an integration that:

  1. Collects and saves card details without charging the customer by using a SetupIntent
  2. Charges the card off-session and has a recovery flow to handle declines and authentication requests

There are several test cards you can use to make sure this integration is ready for production. Use them with any CVC, postal code, and future expiration date.

Number Description
4242424242424242 Succeeds and immediately processes the payment.
4000002500003155 Requires authentication for the initial purchase, but succeeds for subsequent payments (including off-session ones) as long as the card is setup with setup_future_usage.
4000002760003184 Requires authentication for the initial purchase, and fails for subsequent payments (including off-session ones) with an authentication_required decline code.
4000008260003178 Requires authentication for the initial purchase, but fails for subsequent payments (including off-session ones) with an insufficient_funds decline code.
4000000000009995 Always fails (including the initial purchase) with a decline code of insufficient_funds.

For the full list of test cards see our guide on testing.

The Setup Intents API lets you save a customer’s card without an initial payment. This is helpful if you want to onboard customers now, set them up for payments, and charge them in the future—when they’re offline.

Use this integration to set up recurring payments or to create one-time payments with a final amount determined later, often after the customer receives your service.

1 Set up Stripe Client-side Server-side

First, you need a Stripe account. Register now.

Server-side

This integration requires endpoints on your server that talk to the Stripe API. Use our official libraries for access to the Stripe API from your server:

# Available as a gem
gem install stripe
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
# Install through pip
pip install --upgrade stripe
# Or find the Stripe package on http://pypi.python.org/pypi/stripe/
# Find the version you want to pin:
# https://github.com/stripe/stripe-python/blob/master/CHANGELOG.md
# Specify that version in your requirements.txt file
stripe>=2.48.0,<3.0
# Install the PHP library via Composer
composer require stripe/stripe-php
# Or download the source directly: https://github.com/stripe/stripe-php/releases
/*
 For Gradle, add the following dependency to your build.gradle and replace {VERSION} with
 the version number you want to use from
 - https://mvnrepository.com/artifact/com.stripe/stripe-java or
 - https://github.com/stripe/stripe-java/releases/latest
*/
implementation "com.stripe:stripe-java:{VERSION}"
<!--
  For Maven, add the following dependency to your POM and replace {VERSION} with the
  version number you want to use from
  - https://mvnrepository.com/artifact/com.stripe/stripe-java or
  - https://github.com/stripe/stripe-java/releases/latest
-->
<dependency>
  <groupId>com.stripe</groupId>
  <artifactId>stripe-java</artifactId>
  <version>{VERSION}</version>
</dependency>
# For other environments, manually install the following JARs:
# - The Stripe JAR from https://github.com/stripe/stripe-java/releases/latest
# - Google Gson from https://github.com/google/gson
# Install via npm
npm install --save stripe
# Make sure your project is using Go Modules
go mod init
# Install stripe-go
go get -u github.com/stripe/stripe-go/v71
// Then import the package
import (
  "github.com/stripe/stripe-go/v71"
)
# Install via dotnet
dotnet add package Stripe.net
dotnet restore
# Or install via NuGet
PM> Install-Package Stripe.net

Client-side

The Android SDK is open source and fully documented.

To install the SDK, add stripe-android to the dependencies block of your app/build.gradle file:

apply plugin: 'com.android.application'

android { ... }

dependencies {
  // ...

  // Stripe Android SDK
  implementation 'com.stripe:stripe-android:16.0.1'
}

Configure the SDK with your Stripe publishable key so that it can make requests to the Stripe API, such as in your Application subclass:

import com.stripe.android.PaymentConfiguration

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "pk_test_TYooMQauvdEDq54NiTphI7jx"
        )
    }
}

import com.stripe.android.PaymentConfiguration;

public class MyApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        PaymentConfiguration.init(
            getApplicationContext(),
            "pk_test_TYooMQauvdEDq54NiTphI7jx"
        );
    }
}

2 Create a Customer before setup Server-side

To set a card up for future payments, it must be attached to a Customer.

You should create a Customer object when your customer creates an account with your business. If your customer is making a payment as a guest, you can create a Customer object before payment and associate it with your own internal representation of the customer’s account later.

Create or retrieve a Customer to associate with these card details. Include the following code on your server to create a new Customer.

curl https://api.stripe.com/v1/customers \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -X POST

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

customer = Stripe::Customer.create

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

customer = stripe.Customer.create()

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

$customer = \Stripe\Customer::create();

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

CustomerCreateParams params =
  CustomerCreateParams.builder()
    .build();

Customer customer = Customer.create(params);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const customer = await stripe.customers.create();

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.CustomerParams{}
c, _ := customer.New(params)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var options = new CustomerCreateOptions{};

var service = new CustomerService();
var customer = service.Create(options);

Associate the ID of the Customer object with your own internal representation of a customer, if you have one.

3 Create a SetupIntent Server-side

A SetupIntent is an object that represents your intent to set up a payment method for future payments.

The SetupIntent object contains a client secret, a unique key that you pass to your app. The client secret lets you perform certain actions on the client, such as confirming the setup and updating payment method details, while hiding sensitive information like customer. The client secret can be used to validate and authenticate card details via the credit card networks. Because of its sensitive nature, the client secret should not be logged, embedded in URLs, or exposed to anyone other than the customer.

Server-side

On your server, make an endpoint that creates a SetupIntent and returns its client secret to your app.

curl https://api.stripe.com/v1/setup_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d customer="{{CUSTOMER_ID}}"

require 'sinatra'
require 'json'
require 'stripe'

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

get '/card-wallet' do
  setup_intent = Stripe::SetupIntent.create({
    customer: customer['id'],
  })
  client_secret = setup_intent['client_secret']
  # Pass the client secret to the client
end

import stripe
import json

from flask import request, render_template

app = Flask(__name__, static_folder=".",
            static_url_path="", template_folder=".")

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

@app.route('/card-wallet')
def card_wallet():
  setup_intent = stripe.SetupIntent.create(
    customer=customer['id']
  )
  client_secret = setup_intent.client_secret
  # Pass the client secret to the client

if __name__ == '__main__':
    app.run()


// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

# vendor using composer
require_once('vendor/autoload.php');

$setup_intent = \Stripe\SetupIntent::create([
  'customer' => $customer->id
]);
$client_secret = $setup_intent->client_secret
// Pass the client secret to the client

import java.util.HashMap;
import java.util.Map;

import com.stripe.Stripe;
import com.stripe.model.SetupIntent;

public class StripeJavaQuickStart {
  public static void main(String[] args) {
    // Set your secret key. Remember to switch to your live secret key in production!
    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

    Map<String, Object> params = new HashMap<>();
    params.put("customer", customer.getId());
    SetupIntent setupIntent = SetupIntent.create(params);
    String clientSecret = setupIntent.getClientSecret();
    // Pass the client secret to the client
  }
}

// Using Express
const express = require('express');
const app = express();
app.use(express.json());
const { resolve } = require("path");

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const setupIntent = await stripe.setupIntents.create({
  customer: customer.id,
});
const clientSecret = setupIntent.client_secret;
// Pass the client secret to the client

package main

import (
  "encoding/json"
  "log"
  "net/http"

  "github.com/stripe/stripe-go/v71"
  "github.com/stripe/stripe-go/v71/setupintent"
)

func main() {
  // Set your secret key. Remember to switch to your live secret key in production!
  // See your keys here: https://dashboard.stripe.com/account/apikeys
  stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"
  params := &stripe.SetupIntentParams{
    Customer: stripe.String(customer.ID),
  }
  si, _ := setupintent.New(params)
  clientSecret := si.ClientSecret
  // Pass the client secret to the client
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

using System;
using Microsoft.AspNetCore.Mvc;
using Stripe;

namespace StripeExampleApi.Controllers
{
    [Route("/card-wallet")]
    public class CardWalletController : Controller
    {
        public IActionResult Index()
        {
          var options = new SetupIntentCreateOptions{
              Customer = "{{CUSTOMER_ID}}",
          };
          var service = new SetupIntentService();
          SetupIntent setupIntent = service.Create(options);
          var clientSecret = setupIntent.ClientSecret;
          // Pass the client secret to the client
        }
    }
}

If you only plan on using the card for future payments when your customer is present during the checkout flow, set the usage parameter to on_session to optimize authorization rates.

Client-side

On the client, request a SetupIntent from your server.

class CheckoutActivity : AppCompatActivity() {
   private lateinit var setupIntentClientSecret: String

   private fun loadPage() {
       // Request a SetupIntent from your server and store its client secret
       // Click Open on GitHub to see a full implementation
   }
}
public class CheckoutActivity extends AppCompatActivity {
    private String setupIntentClientSecret;

    private void loadPage() {
        // Request a SetupIntent from your server and store its client secret
        // Click Open on GitHub to see a full implementation
    }
}

4 Collect card details Client-side

When the customer submits the payment form, collect their card details using CardInputWidget, a drop-in UI component provided by the SDK.

CardInputWidget performs on-the-fly validation and formatting.

Call the getPaymentMethodCard method to retrieve the card details. Pass the collected information into new PaymentMethodCreateParams and PaymentMethod.BillingDetails instances to create a ConfirmSetupIntentParams instance.

// Collect card details
val cardInputWidget =
    findViewById<CardInputWidget>(R.id.cardInputWidget)
cardInputWidget.paymentMethodCreateParams?.let { paymentMethodParams ->
    // Create SetupIntent confirm parameters with the above
    val confirmParams = ConfirmSetupIntentParams
        .create(paymentMethodParams, setupIntentClientSecret)
    stripe.confirmSetupIntent(this, confirmParams)
}

// Collect card details
CardInputWidget cardInputWidget = findViewById(R.id.cardInputWidget);
PaymentMethodCreateParams.Card card = cardInputWidget.getPaymentMethodCard();

if (card != null) {
    PaymentMethod.BillingDetails billingDetails =
        new PaymentMethod.BillingDetails.Builder()
            // ...
            .build();
    // Create SetupIntent confirm parameters with the above
    PaymentMethodCreateParams paymentMethodParams = PaymentMethodCreateParams
            .create(card, billingDetails);
    ConfirmSetupIntentParams confirmParams = ConfirmSetupIntentParams
            .create(paymentMethodParams, setupIntentClientSecret);
    stripe.confirmSetupIntent(this, confirmParams);
}

To complete the setup, pass the SetupIntentParams object with the current Activity to Stripe#confirmSetupIntent(). The SetupIntent verifies that the card information your customer is using is valid on the network. However, automatic verification isn’t always performed. For details on this, see Check if a card is valid without a charge. Also, don’t maintain long-lived, unhandled SetupIntents as they may no longer be valid when you call Stripe#confirmSetupIntent().

Some payment methods require additional authentication steps in order to complete payment. The SDK manages the payment confirmation and authentication flow, which may involve presenting additional screens required for authentication. For more information on 3D Secure authentication and customizing the authentication experience, see Supporting 3D Secure Authentication on Android.

The result of the flow returns to your calling Activity via Activity#onActivityResult(). Handle the result by calling Stripe#onSetupResult() within Activity#onActivityResult(). The SetupIntentResult returned in ApiResultCallback#onSuccess() has two fields:

  • setupIntent: A SetupIntent object retrieved after confirmation and authentication
  • outcome: A <a href=”https://stripe.dev/stripe-android/stripe/com.stripe.android/-stripe-intent-result/index.html#com.stripe.android/StripeIntentResult/outcome/#/PointingToDeclaration/ class=”external”>StripeIntentResult.Outcome</a> value that indicates the outcome of authentication
    • SUCCEEDED - confirmation or authentication succeeded
    • FAILED - confirmation or authentication failed
    • CANCELED - the customer canceled required authentication
    • TIMEDOUT - the authentication attempt timed-out
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    val weakActivity = WeakReference<Activity>(this)

    // Handle the result of stripe.confirmSetupIntent
    stripe.onSetupResult(requestCode, data, object : ApiResultCallback<SetupIntentResult> {
        override fun onSuccess(result: SetupIntentResult) {
            val setupIntent = result.intent
            val status = setupIntent.status
            if (status == StripeIntent.Status.Succeeded) {
                // Setup completed successfully
            } else if (status == StripeIntent.Status.RequiresPaymentMethod) {
                // Setup failed
            }
        }

        override fun onError(e: Exception) {
            // Setup request failed
        }
    })
}

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    WeakReference<Activity> weakActivity = new WeakReference<>(this);

    // Handle the result of stripe.confirmSetupIntent
    stripe.onSetupResult(requestCode, data, new ApiResultCallback<SetupIntentResult>() {
        @Override
        public void onSuccess(@NonNull SetupIntentResult result) {
            SetupIntent setupIntent = result.getIntent();
            SetupIntent.Status status = setupIntent.getStatus();
            if (status == SetupIntent.Status.Succeeded) {
                // Setup completed successfully
            } else if (status == SetupIntent.Status.RequiresPaymentMethod) {
                // Setup failed – allow retrying
            }
        }

        @Override
        public void onError(@NonNull Exception e) {
            // Setup request failed
        }
    });
}

You now have a flow to collect card details and handle any authentication requests. Use the test card 4000 0025 0000 3155, along with any CVC, postal code, and future expiration date to test the authentication process.

When the SetupIntent succeeds, the resulting PaymentMethod ID (in setupIntent.getPaymentMethodId()) will be saved to the provided Customer.

5 Charge the saved card later Server-side

When you are ready to charge your customer off-session, use the Customer and PaymentMethod IDs to create a PaymentIntent.

To find a card to charge, list the PaymentMethods associated with your Customer.

curl https://api.stripe.com/v1/payment_methods \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d customer="{{CUSTOMER_ID}}" \
  -d type=card \
  -G

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

Stripe::PaymentMethod.list({
  customer: '{{CUSTOMER_ID}}',
  type: 'card',
})

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

stripe.PaymentMethod.list(
  customer="{{CUSTOMER_ID}}",
  type="card",
)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

\Stripe\PaymentMethod::all([
  'customer' => '{{CUSTOMER_ID}}',
  'type' => 'card',
]);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

PaymentMethodListParams params =
  PaymentMethodListParams.builder()
    .setCustomer("{{CUSTOMER_ID}}")
    .setType(PaymentMethodListParams.Type.CARD)
    .build();

PaymentMethodCollection paymentMethods = PaymentMethod.list(params);

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

const paymentMethods = await stripe.paymentMethods.list({
  customer: '{{CUSTOMER_ID}}',
  type: 'card',
});

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentMethodListParams{
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  Type: stripe.String(string(stripe.PaymentMethodTypeCard)),
}
i := paymentmethod.List(params)
for i.Next() {
  pm := i.PaymentMethod()
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

var options = new PaymentMethodListOptions
{
  Customer = "{{CUSTOMER_ID}}",
  Type = "card",
};

var service = new PaymentMethodService();
var paymentMethods = service.List(options);

When you have the Customer and PaymentMethod IDs, create a PaymentIntent with the amount and currency of the payment. Set a few other parameters to make the off-session payment:

  • Set off_session to true to indicate that the customer is not in your checkout flow during this payment attempt. This causes the PaymentIntent to throw an error if authentication is required.
  • Set the value of the PaymentIntent’s confirm property to true, which causes confirmation to occur immediately when the PaymentIntent is created.
  • Set payment_method to the ID of the PaymentMethod and customer to the ID of the Customer.
curl https://api.stripe.com/v1/payment_intents \
  -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
  -d amount=1099 \
  -d currency=usd \
  -d customer="{{CUSTOMER_ID}}" \
  -d payment_method="{{PAYMENT_METHOD_ID}}" \
  -d off_session=true \
  -d confirm=true

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

begin
  intent = Stripe::PaymentIntent.create({
    amount: 1099,
    currency: 'usd',
    customer: '{{CUSTOMER_ID}}',
    payment_method: '{{PAYMENT_METHOD_ID}}',
    off_session: true,
    confirm: true,
  })
rescue Stripe::CardError => e
  # Error code will be authentication_required if authentication is needed
  puts "Error is: #{e.error.code}"
  payment_intent_id = e.error.payment_intent.id
  payment_intent = Stripe::PaymentIntent.retrieve(payment_intent_id)
  puts payment_intent.id
end

# Set your secret key. Remember to switch to your live secret key in production!
# See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.api_key = 'sk_test_4eC39HqLyjWDarjtT1zdp7dc'

try:
  stripe.PaymentIntent.create(
    amount=1099,
    currency='usd',
    customer='{{CUSTOMER_ID}}',
    payment_method='{{PAYMENT_METHOD_ID}}',
    off_session=True,
    confirm=True,
  )
except stripe.error.CardError as e:
  err = e.error
  # Error code will be authentication_required if authentication is needed
  print("Code is: %s" % err.code)
  payment_intent_id = err.payment_intent['id']
  payment_intent = stripe.PaymentIntent.retrieve(payment_intent_id)

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
\Stripe\Stripe::setApiKey('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

try {
  \Stripe\PaymentIntent::create([
    'amount' => 1099,
    'currency' => 'usd',
    'customer' => '{{CUSTOMER_ID}}',
    'payment_method' => '{{PAYMENT_METHOD_ID}}',
    'off_session' => true,
    'confirm' => true,
  ]);
} catch (\Stripe\Exception\CardException $e) {
  // Error code will be authentication_required if authentication is needed
  echo 'Error code is:' . $e->getError()->code;
  $payment_intent_id = $e->getError()->payment_intent->id;
  $payment_intent = \Stripe\PaymentIntent::retrieve($payment_intent_id);
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
Stripe.apiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

PaymentIntentCreateParams params =
  PaymentIntentCreateParams.builder()
    .setCurrency("usd")
    .setAmount(1099)
    .setPaymentMethod("{{PAYMENT_METHOD_ID}}")
    .setCustomer("{{CUSTOMER_ID}}")
    .setConfirm(true)
    .setOffSession(true)
    .build();
try {
  PaymentIntent.create(params);
} catch (CardException err) {
  // Error code will be authentication_required if authentication is needed
  System.out.println("Error code is : " + e.getCode());
  String paymentIntentId = e.getStripeError().getPaymentIntent().getId();
  PaymentIntent paymentIntent = PaymentIntent.retrieve(paymentIntentId);
  System.out.println(paymentIntent.getId());
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
const stripe = require('stripe')('sk_test_4eC39HqLyjWDarjtT1zdp7dc');

try {
  const paymentIntent = await stripe.paymentIntents.create({
    amount: 1099,
    currency: 'usd',
    customer: '{{CUSTOMER_ID}}',
    payment_method: '{{PAYMENT_METHOD_ID}}',
    off_session: true,
    confirm: true,
  });
} catch (err) {
  // Error code will be authentication_required if authentication is needed
  console.log('Error code is: ', err.code);
  const paymentIntentRetrieved = await stripe.paymentIntents.retrieve(err.raw.payment_intent.id);
  console.log('PI retrieved: ', paymentIntentRetrieved.id);
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
stripe.Key = "sk_test_4eC39HqLyjWDarjtT1zdp7dc"

params := &stripe.PaymentIntentParams{
  Amount: stripe.Int64(1099),
  Currency: stripe.String(string(stripe.CurrencyUSD)),
  Customer: stripe.String("{{CUSTOMER_ID}}"),
  PaymentMethod: stripe.String("{{PAYMENT_METHOD_ID}}"),
  Confirm: stripe.Bool(true),
  OffSession: stripe.Bool(true),
}

_, err := paymentintent.New(params)

if err != nil {
  if stripeErr, ok := err.(*stripe.Error); ok {
    // Error code will be authentication_required if authentication is needed
    fmt.Printf("Error code: %v", stripeErr.Code)

    paymentIntentID := stripeErr.PaymentIntent.ID
    paymentIntent, _ := paymentintent.Get(paymentIntentID, nil)

    fmt.Printf("PI: %v", paymentIntent.ID)
  }
}

// Set your secret key. Remember to switch to your live secret key in production!
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.ApiKey = "sk_test_4eC39HqLyjWDarjtT1zdp7dc";

try
{
  var service = new PaymentIntentService();
  var options = new PaymentIntentCreateOptions
  {
    Amount = 1099,
    Currency = "usd",
    Customer = "{{CUSTOMER_ID}}",
    PaymentMethod = "{{PAYMENT_METHOD_ID}}",
    Confirm = true,
    OffSession = true,
  };
  service.Create(options);
}
catch (StripeException e)
{
  switch (e.StripeError.ErrorType)
  {
    case "card_error":
      // Error code will be authentication_required if authentication is needed
      Console.WriteLine("Error code: " + e.StripeError.Code);
      var paymentIntentId = e.StripeError.PaymentIntent.Id;
      var service = new PaymentIntentService();
      var paymentIntent = service.Get(paymentIntentId);

      Console.WriteLine(paymentIntent.Id);
      break;
    default:
      break;
  }
}

Inspect the status property of the PaymentIntent to confirm that the payment completed successfully. If the payment attempt succeeded, the PaymentIntent’s status is succeeded and the off-session payment is complete.

Start a recovery flow

If the PaymentIntent has any other status, the payment did not succeed and the request fails. Notify your customer to return to your application (e.g., by email, text, push notification) to complete the payment. We recommend creating a recovery flow in your app that shows why the payment failed initially and lets your customer retry.

In your recovery flow, retrieve the PaymentIntent via its client secret. Check the PaymentIntent’s lastPaymentError to inspect why the payment attempt failed. For card errors, you can show the user the last payment error’s message. Otherwise, you can show a generic failure message.

fun startRecoveryFlow(clientSecret: String) {
    AsyncTask.execute {
        val stripe = Stripe(applicationContext, PaymentConfiguration.getInstance(applicationContext).publishableKey)
        val paymentIntent = stripe.retrievePaymentIntentSynchronous(clientSecret)
        var failureReason = "Payment failed, try again" // Default to a generic error message
        paymentIntent?.lastPaymentError?.let { lastPaymentError ->
            if (lastPaymentError.type == PaymentIntent.Error.Type.CardError) {
                lastPaymentError.message?.let { errorMessage ->
                    failureReason = errorMessage
                }
            }
        }
        // Display the failure reason to your customer
    }
}

public void startRecoveryFlow(@NonNull  String clientSecret) {
    AsyncTask.execute(new Runnable() {
        @Override
        public void run() {
            final Stripe stripe = new Stripe(
                getApplicationContext(),
                PaymentConfiguration.getInstance(this).getPublishableKey()
            );
            try {
                final PaymentIntent paymentIntent =
                    stripe.retrievePaymentIntentSynchronous(clientSecret);
                final PaymentIntent.Error lastPaymentError = paymentIntent != null ?
                    paymentIntent.getLastPaymentError() : null;
                final String failureReason;
                if (lastPaymentError != null &&
                    PaymentIntent.Error.Type.CardError.equals(lastPaymentError.getType())) {
                    failureReason = lastPaymentError.getMessage();
                } else {
                    failureReason = "Payment failed, try again"; // Default to a generic error message
                }
                // Display the failure reason to your customer
            } catch (Exception e) {
                // Handle error
            }
        }
    });
}

Let your customer try again

Give the customer the option to update or remove their saved card and try payment again in your recovery flow. Follow the same steps you did to accept their initial payment with one difference—confirm the original, failed PaymentIntent by reusing its client secret instead of creating a new one.

If the payment failed because it requires authentication, try again with the existing PaymentMethod instead of creating a new one.

fun startRecoveryFlow(clientSecret: String) {
    // ...continued from previous step
    val lastPaymentError = paymentIntent.lastPaymentError
    val lastPaymentMethodId = lastPaymentError.paymentMethod?.id
    if (lastPaymentError?.code == "authentication_required" && lastPaymentMethodId != null) {
        // Payment failed because authentication is required, reuse the PaymentMethod
        val paymentIntentParams =
            ConfirmPaymentIntentParams.createWithPaymentMethodId(
                lastPaymentMethodId,
                clientSecret // Reuse the existing PaymentIntent
            )
        // Submit the payment...
        stripe.confirmPayment(this, paymentIntentParams)
    } else {
        // Collect a new PaymentMethod from the customer...
    }
}
    private void startRecoveryFlow(@NonNull String clientSecret) {
        // ...continued from previous step
        final String lastPaymentMethodId;
        if (lastPaymentError != null && lastPaymentError.getPaymentMethod() != null) {
            lastPaymentMethodId = lastPaymentError.getPaymentMethod().id;
        } else {
            lastPaymentMethodId = null;
        }

        if (lastPaymentError != null &&
                "authentication_required".equals(lastPaymentError.getCode()) &&
                lastPaymentMethodId != null) {
            // Payment failed because authentication is required, reuse the PaymentMethod
            final ConfirmPaymentIntentParams params =
                    ConfirmPaymentIntentParams.createWithPaymentMethodId(
                            lastPaymentMethodId,
                            clientSecret // Reuse the existing PaymentIntent
                    );
            // Submit the payment...
            stripe.confirmPayment(this, params);
        } else {
            // Collect a new PaymentMethod from the customer...
        }
    }
}

6 Test the integration

By this point you should have an integration that:

  1. Collects and saves card details without charging the customer by using a SetupIntent
  2. Charges the card off-session and has a recovery flow to handle declines and authentication requests

There are several test cards you can use to make sure this integration is ready for production. Use them with any CVC, postal code, and future expiration date.

Number Description
4242424242424242 Succeeds and immediately processes the payment.
4000002500003155 Requires authentication for the initial purchase, but succeeds for subsequent payments (including off-session ones) as long as the card is setup with setup_future_usage.
4000002760003184 Requires authentication for the initial purchase, and fails for subsequent payments (including off-session ones) with an authentication_required decline code.
4000008260003178 Requires authentication for the initial purchase, but fails for subsequent payments (including off-session ones) with an insufficient_funds decline code.
4000000000009995 Always fails (including the initial purchase) with a decline code of insufficient_funds.

For the full list of test cards see our guide on testing.

Was this page helpful?
Questions? Contact us.
Developer tutorials on YouTube.
You can unsubscribe at any time. Read our privacy policy.
On this page
Set up Stripe
Create a Checkout Session
Redirect to Checkout
Retrieve the Checkout Session
Retrieve the SetupIntent
Use the payment method