Accéder directement au contenu
Créez un compte ou connecter-vous
Logo de la documentation Stripe
/
Créez un compteConnectez-vous
Aperçu
Billing
PrésentationÀ propos des API Billing
Abonnements
Tax
Présentation
Rapports
PrésentationRapports sur plusieurs comptes
Données
Présentation

Créer une intégration pour les abonnements

Créez et gérez des abonnements pour les paiements récurrents.

Page d'abonnement à prix fixe avec le Payment Element
Low-code

Personnalisez avec l’API Appearance.

Utilisez ce guide pour apprendre à vendre des abonnements à prix fixe. Vous utiliserez lePayment Element avec l’API Checkout Sessions pour créer un formulaire de paiement personnalisé que vous intégrerez dans votre application.

Si vous ne souhaitez pas créer un formulaire de paiement personnalisé, vous pouvez intégrer Checkout. Pour une version immersive de ce guide d’intégration de bout en bout, consultez le guide de démarrage Billing.

Si vous n’êtes pas prêt à coder une intégration, vous pouvez configurer des abonnements de base manuellement dans le Dashboard. Vous pouvez également utiliser Payment Links pour configurer des abonnements sans écrire la moindre ligne de code. Apprenez-en plus sur la conception d’une intégration pour comprendre les décisions à prendre et les ressources dont vous aurez besoin.

Ce que vous allez créer

Ce guide vous explique comment :

  • Modélisez votre entreprise en créant un catalogue de produits.
  • Créez un processus d’inscription qui génère automatiquement un client.
  • Créer des abonnements et collecter les informations de paiement de vos clients.
  • Tester et surveiller l’état des paiements et de l’abonnement.
  • Permettre aux clients de modifier leur offre ou de résilier l’abonnement.

Définitions des objets API

RessourceDéfinition
CustomerReprésente un client qui achète un abonnement. Utilisez l’objet Customer associé à un abonnement pour effectuer et suivre ses paiements récurrents et gérer les produits auxquels il est abonné.
EntitlementReprésente l’accès d’un client à une fonctionnalité incluse dans un produit de service auquel il est abonné. Lorsque vous créez un abonnement représentant l’achat récurrent d’un produit par un client, un droit d’accès actif est automatiquement créé pour chaque fonctionnalité associée à ce produit. Lorsqu’un client accède à vos services, utilisez ses droits d’accès actifs pour activer les fonctionnalités incluses dans son abonnement.
FeatureReprésente une fonctionnalité à laquelle vos clients peuvent accéder lorsqu’ils s’abonnent à un produit de service. Vous pouvez inclure des fonctionnalités dans un produit en créant des objets ProductFeatures.
InvoiceRelevé des montants dus par un client et qui suit les états des paiements, de l’ébauche initiale au paiement ou à la finalisation. Les abonnements génèrent automatiquement des factures.
PaymentIntentUn moyen de créer des tunnels de paiement dynamiques. Un PaymentIntent suit le cycle de vie du tunnel de paiement d’un client et déclenche des étapes d’authentification supplémentaires lorsque des mandats réglementaires, des règles Radar personnalisées de lutte contre la fraude, ou des moyens de paiement avec redirection l’exigent. Les objets Invoice créent automatiquement des PaymentIntents.
PaymentMethodLes moyens de paiement qu’un client utilise pour payer vos produits. Vous pouvez par exemple enregistrer une carte bancaire dans un objet Customer et l’utiliser pour les paiements récurrents de ce client. Généralement utilisés avec les API Payment Intents ou Setup Intents.
PriceDéfinit le tarif unitaire, la devise et le cycle de facturation d’un produit.
ProductUn bien ou un service que votre entreprise vend. Un produit de service peut comporter une ou plusieurs fonctionnalités.
ProductFeatureReprésente l’inclusion d’une fonctionnalité unique dans un produit unique. Chaque produit est associé à un objet ProductFeature pour chaque fonctionnalité qu’il inclut, et chaque fonctionnalité est associée à un objet ProductFeature pour chaque produit qui l’inclut.
SubscriptionReprésente l’achat récurrent et programmé d’un produit par un client. L’abonnement permet d’encaisser des paiements et de fournir des livraisons répétées ou un accès continu à un produit.

Voici un exemple de la manière dont les produits, les fonctionnalités et les droits d’accès fonctionnent ensemble. Imaginons que vous créez un service récurrent proposant deux niveaux : un produit standard avec des fonctionnalités de base et un produit Advanced qui ajoute des fonctionnalités étendues.

  1. Vous créez deux fonctionnalités : basic_features et extended_features.
  2. Vous créez deux produits : standard_product et advanced_product.
  3. Pour le produit standard, vous créez un objet ProductFeature qui associe basic_features à standard_product.
  4. Pour le produit avancé, vous créez deux objets ProductFeature : un qui associe basic_features à advanced_product et un qui associe extended_features à advanced_product.

Un client, first_customer, s’abonne au produit standard. Lorsque vous créez l’abonnement, Stripe crée automatiquement un objet Entitlement qui associe first_customer à basic_features.

Un autre client, second_customer, s’abonne au produit avancé. Lorsque vous créez l’objet Subscription correspondant, Stripe crée automatiquement deux objets Entitlement : un qui associe second_customer à basic_features, et un qui associe second_customer à extended_features.

Pour savoir quelles fonctionnalités vous devez fournir à un client, récupérez ses droits d’accès actifs ou écoutez l’événement Active Entitlement Summary. Il n’est pas nécessaire de récupérer ses abonnements, produits et fonctionnalités.

Configurer Stripe

Installez le client Stripe de votre choix :

Command Line
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Available as a gem
sudo gem install stripe
Gemfile
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'

Installez ensuite la Stripe CLI. La CLI permet de tester les webhooks et d’exécuter des appels API vers Stripe. Ce guide explique comment utiliser la CLI pour configurer un modèle de tarification dans une section ultérieure.

Command Line
homebrew
Installer à partir d'une source
No results
# Install Homebrew to run this command: https://brew.sh/
brew install stripe/stripe-cli/stripe

# Connect the CLI to your dashboard
stripe login

Pour davantage d’options d’installation, consultez la page consacrée à l’interface de ligne de commande Stripe.

Créer le modèle tarifaire
Stripe CLI ou Dashboard

Créez vos produits et leurs tarifs dans le Dashboard ou via l’interface de ligne de commande Stripe.

Cet exemple utilise un service à tarif fixe avec deux options de niveau de service différentes : Basic et Premium. Pour chaque option de niveau de service, vous devez créer un produit et un tarif récurrent. (Si vous souhaitez ajouter un paiement ponctuel, par exemple des frais d’installation, créez un troisième produit avec un tarif unique. Par souci de simplicité, cet exemple n’inclut pas de paiement ponctuels.)

Dans cet exemple, chaque produit est facturé mensuellement. Le tarif du produit de base est de 5 USD. Celui du produit premium est de 15 USD.

Accédez à la page Ajouter un produit et créez deux produits. Ajoutez un tarif pour chaque produit, avec une période de facturation mensuelle récurrente :

  • Produit Premium : service Premium avec fonctionnalités supplémentaires

    • Prix : Appuyez sur Payer 15 USD.

  • Produit de base : service de base avec fonctionnalités minimales

    • Prix : Forfaitaire | 5 USD

Après avoir créé vos tarifs, enregistrez les ID de tarif de manière à pouvoir les utiliser dans d’autres étapes. Les ID de tarif se présentent sous la forme suivante : price_G0FvDp6vZvdwRZ.

Lorsque vous le souhaitez, cliquez sur le bouton Copier en mode production en haut à droite de la page pour dupliquer votre produit de l’environnement de test en mode production.

Créer le Client
Client et serveur

Stripe a besoin d’un Client pour chaque abonnement. Dans la partie frontale de votre application, collectez toutes les informations nécessaires auprès de vos utilisateurs et transmettez-les au back end.

Si vous avez besoin de collecter des données d’adresse, Address Element vous permet de collecter une adresse de livraison ou de facturation pour vos clients. Pour plus d’informations sur l’Address Element, voir la page Address Element.

register.html
<form id="signup-form">
  <label>
    Email
    <input id="email" type="email" placeholder="Email address" value="test@example.com" required />
  </label>

  <button type="submit">
    Register
  </button>
</form>
register.js
const emailInput = document.querySelector('#email');

fetch('/create-customer', {
  method: 'post',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    email: emailInput.value,
  }),
}).then(r => r.json());

Sur le serveur, créez l’objet Stripe Customer.

Remarque

Make sure you store the Customer ID to use in the Checkout Session

Command Line
cURL
Stripe CLI
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
curl https://api.stripe.com/v1/customers \
  -u "
sk_test_BQokikJOvBiI2HlWgH4olfQ2
:" \
  -d email={{CUSTOMER_EMAIL}} \
  -d name={{CUSTOMER_NAME}} \
  -d "shipping[address][city]"=Brothers \
  -d "shipping[address][country]"=US \
  -d "shipping[address][line1]"="27 Fredrick Ave" \
  -d "shipping[address][postal_code]"=97712 \
  -d "shipping[address][state]"=CA \
  -d "shipping[name]"={{CUSTOMER_NAME}} \
  -d "address[city]"=Brothers \
  -d "address[country]"=US \
  -d "address[line1]"="27 Fredrick Ave" \
  -d "address[postal_code]"=97712 \
  -d "address[state]"=CA

Créer une session Checkout
Serveur

Côté back-end, définissez un endpoint qui crée la session et que le front-end pourra appeler. Cette étape nécessite l’identifiant de prix de l’abonnement choisi par le client, transmis automatiquement par votre front-end.

Si vous avez créé un prix unique lors de l’étape 2, transmettez également l’identifiant de ce prix. Après avoir créé une session Checkout, veillez à renvoyer la clé secrète du client au client dans la réponse.

Remarque

Vous pouvez utiliser lookup_keys pour récupérer les prix plutôt que les identifiants de prix. Consultez cet exemple concret pour plus de détails.

Ruby
Python
.NET
PHP
Java
Node.js
Go
No results
require 'stripe'
require 'sinatra'

# This test secret API key is a placeholder. Don't include personal details in requests with this key.
# To see your test secret API key embedded in code samples, sign in to your Stripe account.
# You can also find your test secret API key at https://dashboard.stripe.com/test/apikeys.
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'

Stripe.api_version = '2025-09-30.clover'

set :static, true
set :port, 4242

YOUR_DOMAIN = 'http://localhost:3000'

post '/create-checkout-session' do
  content_type 'application/json'

  session = Stripe::Checkout::Session.create({
    ui_mode: 'custom',
    # Provide the customer ID of the customer you previously created
    customer: '{{CUSTOMER_ID}}',
    line_items: [{
      # Provide the exact Price ID (for example, price_1234) of the product you want to sell
      price: '{{PRICE_ID}}',
      quantity: 1,
    }],
    mode: 'subscription',
    return_url: YOUR_DOMAIN + '/return?session_id={CHECKOUT_SESSION_ID}',
  })

  { clientSecret: session.client_secret }.to_json
end

Depuis votre Dashboard,activez les moyens de paiement que vous souhaitez accepter de vos clients. Checkout prend en charge plusieurs moyens de paiement.

Initialiser Checkout
Client

Créez soit une promesse clientSecret qui se résout avec le secret client, soit définissez-le directement comme secret. Appelez initCheckout, en passant clientSecret. initCheckout renvoie une promesse qui se résout en une instance de Checkout.

L’objet paiement constitue la base de votre page de paiement et contient les données de la session Checkout ainsi que les méthodes permettant de mettre à jour la session.

L’objet renvoyé par actions.getSession() contient vos informations tarifaires. Nous vous recommandons de lire et d’afficher le total et les lineItems de la session dans votre interface utilisateur.

Cela vous permet d’activer de nouvelles fonctionnalités avec un minimum de modifications du code. Par exemple, l’ajout de prix manuels des devises ne nécessite aucune modification de l’interface utilisateur si vous affichez le total.

checkout.js
const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
  .then((response) => response.json())
  .then((json) => json.checkoutSessionClientSecret);
const checkout = stripe.initCheckout({clientSecret});
const loadActionsResult = await checkout.loadActions();
if (loadActionsResult.type === 'success') {
  const session = loadActionsResult.actions.getSession();
  const checkoutContainer = document.getElementById('checkout-container');
  checkoutContainer.append(JSON.stringify(session.lineItems, null, 2));
  checkoutContainer.append(document.createElement('br'));
  checkoutContainer.append(`Total: ${session.total.total.amount}`);
}
index.html
<div id="checkout-container"></div>

Collecter les informations de paiement
Client

Collectez les informations de paiement de votre client à l’aide de Payment Element. Payment Element est un composant d’interface utilisateur préconfiguré qui simplifie la collecte des informations pour de nombreux moyens de paiement.

Tout d’abord, créez un élément DOM de conteneur pour monter le composant Payment Element. Créez ensuite une instance du Payment Element à l’aide de checkout.createPaymentElement et montez-la en appelant element.mount et en fournissant soit un sélecteur CSS, soit l’élément DOM du conteneur.

index.html
<div id="payment-element"></div>
checkout.js
const paymentElement = checkout.createPaymentElement();
paymentElement.mount('#payment-element');

Consultez la documentation Stripe.js pour connaître les options prises en charge.

Vous pouvez personnaliser l’apparence de tous les Elements en transmettant elementsOptions.appearance lors de l’initialisation de Checkout sur le front-end.

Envoyer le paiement
Côté client

Rendre un bouton Pay qui appelle l’instance confirmer à partir de l’instance paiement pour soumettre le paiement.

index.html
<button id="pay-button">Pay</button>
<div id="confirm-errors"></div>
checkout.js
const checkout = stripe.initCheckout({clientSecret});
const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  const button = document.getElementById('pay-button');
  const errors = document.getElementById('confirm-errors');
  button.addEventListener('click', () => {
    // Clear any validation errors
    errors.textContent = '';

    actions.confirm().then((result) => {
      if (result.type === 'error') {
        errors.textContent = result.error.message;
      }
    });
  });
}

Écouter les webhooks
Serveur

Pour compléter l’intégration, vous devez traiter les webhooks envoyés par Stripe. Ces événements se déclenchent lorsqu’un statut change dans Stripe, par exemple quand un abonnement génère une nouvelle facture. Dans votre application, configurez un gestionnaire HTTP pour accepter les requêtes POST contenant l’événement de webhook et vérifiez la signature de l’événement :

server.rb
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'


post '/webhook' do
  # You can use webhooks to receive information about asynchronous payment events.
  # For more about our webhook events check out https://stripe.com/docs/webhooks.
  webhook_secret = ENV['STRIPE_WEBHOOK_SECRET']
  payload = request.body.read
  if !webhook_secret.empty?

Pendant le développement, utilisez la Stripe CLI pour observer les webhooks et les transmettre à votre formulaire d’inscription. Exécutez ensuite la commande suivante dans un nouveau terminal pendant que votre application de développement est en cours d’exécution :

Command Line
stripe listen --forward-to localhost:4242/webhook

En production, configurez une URL d’endpoint webhook dans le Dashboard, ou utilisez l’API Webhook Endpoints.

Vous devez écouter quelques événements pour effectuer les étapes restantes de ce guide. Consultez lesÉvénements d’abonnement pour plus de détails sur les webhooks spécifiques aux abonnements.

Fournir l'accès à votre service
Client et serveur

Maintenant que l’abonnement est actif, donnez à votre utilisateur l’accès à votre service. Pour ce faire, écoutez les événements customer.subscription.created, customer.subscription.updated et customer.subscription.deleted. Ces événements transmettent un objet d’abonnement qui contient un champ status indiquant si l’abonnement est actif, en retard ou annulé. Consultez le cycle de vie des abonnements pour obtenir la liste complète des états.

Dans votre gestionnaire de webhooks :

  1. Vérifiez l’état de l’abonnement. S’il est actif, cela signifie que l’utilisateur a payé pour votre produit.
  2. Vérifiez le produit auquel le client s’est abonné et accordez-lui l’accès à votre service. Le fait de contrôler le produit plutôt que le tarif vous offre plus de flexibilité si vous devez modifier la tarification ou la période de facturation.
  3. Enregistrez les product.id, subscription.id et subscription.status dans votre base de données avec le customer.id déjà enregistré. Utilisez cet enregistrement pour déterminer quelles fonctionnalités activer pour l’utilisateur dans votre application.

L’état d’un abonnement peut changer à tout moment pendant sa durée de vie, même si votre application n’effectue aucun appel direct à Stripe. Par exemple, un renouvellement peut échouer en raison d’une carte bancaire expirée, ce qui place l’abonnement en état de retard. Ou, si vous implémentez le portail client, un utilisateur peut annuler son abonnement sans passer directement par votre application. Une implémentation correcte de votre gestionnaire permet de synchroniser le statut de votre application avec celui de Stripe.

Annuler l'abonnement
Client et serveur

Il est courant de laisser aux clients la possibilité d’annuler leur abonnement. Cet exemple montre comment ajouter une option d’annulation sur la page des paramètres du compte.

Exemple d'interface de résiliation d'un abonnement.

Paramètres d’un compte ayant la possibilité d’annuler son abonnement

script.js
function cancelSubscription(subscriptionId) {
  return fetch('/cancel-subscription', {
    method: 'post',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      subscriptionId: subscriptionId,
    }),
  })
    .then(response => {
      return response.json();
    })
    .then(cancelSubscriptionResponse => {
      // Display to the user that the subscription has been canceled.
    });
}

Sur le back-end, définissez le endpoint que votre front-end doit appeler.

server.rb
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'


post '/cancel-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  deleted_subscription = Stripe::Subscription.cancel(data['subscriptionId'])

  deleted_subscription.to_json
end

Votre application reçoit un événement customer.subscription.deleted.

Après la résiliation de l’abonnement, mettez à jour votre base de données pour supprimer l’identifiant de l’abonnement Stripe que vous aviez précédemment stocké, et limitez l’accès à votre service.

Lorsqu’un abonnement est annulé, vous ne pouvez pas le réactiver. À la place, collectez les informations de facturation mises à jour auprès de votre client, actualisez son moyen de paiement par défaut et créez un nouvel abonnement à partir de son dossier client existant.

Tester votre intégration

Tester les moyens de paiement

Utilisez le tableau suivant pour tester différents scénarios et moyens de paiement.

Moyen de paiementScénarioMéthode de test
Prélèvement automatique BECSLe montant dû est réglé par prélèvement automatique BECS.Remplissez le formulaire à l’aide du numéro de compte 900123456 et du BSB 000000. La confirmation de la demande de PaymentIntent passe d’abord à l’état de traitement, puis à l’état réussi trois minutes plus tard.
Prélèvement automatique BECSLe paiement de votre client échoue avec un code d’erreur account_closed.Remplissez le formulaire à l’aide du numéro de compte 111111113 et du BSB 000000.
Carte bancaireLe paiement par carte bancaire aboutit et ne nécessite pas d’authentification.Remplissez le formulaire de paiement par carte bancaire en saisissant le numéro de carte 4242 4242 4242 4242 ainsi que la date d’expiration, le CVC et le code postal de votre choix.
Carte bancaireLe paiement par carte bancaire requiert une authentification.Remplissez le formulaire de paiement par carte bancaire en saisissant le numéro de carte 4000 0025 0000 3155 ainsi que la date d’expiration, le CVC et le code postal de votre choix.
Carte bancaireLa carte est refusée avec un code de refus de type insufficient_funds.Remplissez le formulaire de paiement par carte bancaire en saisissant le numéro 4000 0000 0000 9995 ainsi que la date d’expiration, le CVC et le code postal de votre choix…
Prélèvement automatique SEPALe montant dû est réglé par prélèvement automatique SEPA.Remplissez le formulaire à l’aide du numéro de compte AT321904300235473204. Le PaymentIntent confirmé passe d’abord à l’état processing, puis à l’état succeeded trois minutes plus tard.
Prélèvement automatique SEPAL’état du PaymentIntent de votre client passe de processing à requires_payment_method.Remplissez le formulaire à l’aide du numéro de compte AT861904300235473202.

Écouter des événements

Configurez des webhooks pour écouter les événements de changement d’abonnement, tels que les mises à niveau et les annulations. Apprenez-en plus sur les webhooks d’abonnement. Vous pouvez visualiser les événements dans le Dashboard ou via laStripe CLI.

Pour plus d’informations, voir la sectiontester votre intégration Billing.

FacultatifPermettre à vos clients de modifier leurs offres
Client et serveur

Pour permettre à vos clients de modifier leur abonnement, collectez l’identifiant de prix de l’option choisie, puis envoyez-le depuis votre front-end vers un endpoint du back-end. L’identifiant de l’abonnement est également transmis, mais vous pouvez aussi le récupérer depuis votre base de données pour l’utilisateur connecté.

script.js
function updateSubscription(priceId, subscriptionId) {
  return fetch('/update-subscription', {
    method: 'post',
    headers: {
      'Content-type': 'application/json',
    },
    body: JSON.stringify({
      subscriptionId: subscriptionId,
      newPriceId: priceId,
    }),
  })
    .then(response => {
      return response.json();
    })
    .then(response => {
      return response;
    });
}

Sur votre back-end, définissez l’endpoint que votre front-end appellera et transmettez les identifiants de l’abonnement et du nouveau prix. L’abonnement est maintenant Premium, à 15 USD par mois, au lieu de Basic à 5 USD par mois.

server.rb
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'


post '/update-subscription' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  subscription = Stripe::Subscription.retrieve(data['subscriptionId'])

  updated_subscription =
    Stripe::Subscription.update(
      data['subscriptionId'],
      cancel_at_period_end: false,
      items: [
        { id: subscription.items.data[0].id, price: 'price_H1NlVtpo6ubk0m' }
      ]
    )

  updated_subscription.to_json
end

Votre application reçoit un événement customer.subscription.updated.

FacultatifPrévisualiser un changement de tarif
Client et serveur

Lorsqu’un client modifie son abonnement, le montant facturé est souvent réajusté, c’est ce qu’on appelle la proration. Utilisez l’endpoint create preview invoice pour générer et afficher la facture mise à jour à vos clients.

Sur le front-end, transmettez les informations de l’aperçu de création de la facture à un endpoint du back-end.

script.js
function createPreviewInvoice(
  customerId,
  subscriptionId,
  newPriceId,
  trialEndDate
) {
  return fetch('/create-preview-invoice', {
    method: 'post',
    headers: {
      'Content-type': 'application/json',
    },
    body: JSON.stringify({
      customerId: customerId,
      subscriptionId: subscriptionId,
      newPriceId: newPriceId,
    }),
  })
    .then(response => {
      return response.json();
    })
    .then((invoice) => {
      return invoice;
    });
}

Sur le back-end, définissez le endpoint que votre front-end doit appeler.

server.rb
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'


post '/create-preview-invoice' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  subscription = Stripe::Subscription.retrieve(data['subscriptionId'])

  invoice =
    Stripe::Invoice.create_preview(
      customer: data['customerId'],
      subscription: data['subscriptionId'],
      subscription_details: {
        items: [
          { id: subscription.items.data[0].id, deleted: true },
          { price: ENV[data['newPriceId']], deleted: false }
        ]
      }
    )

  invoice.to_json
end

FacultatifAfficher le moyen de paiement du client
Client et serveur

L’affichage de la marque et des quatre derniers chiffres de la carte bancaire de votre client peut aider ce dernier à savoir quelle carte bancaire est débitée, ou encore s’il doit mettre à jour son moyen de paiement.

Sur votre front-end, envoyez l’ID du moyen de paiement à un endpoint du back-end qui récupère les informations du moyen de paiement.

script.js
function retrieveCustomerPaymentMethod(paymentMethodId) {
  return fetch('/retrieve-customer-payment-method', {
    method: 'post',
    headers: {
      'Content-type': 'application/json',
    },
    body: JSON.stringify({
      paymentMethodId: paymentMethodId,
    }),
  })
    .then((response) => {
      return response.json();
    })
    .then((response) => {
      return response;
    });
}

Sur le back-end, définissez le endpoint que votre front-end doit appeler.

server.rb
Ruby
Python
PHP
Java
Node.js
Go
.NET
No results
# Set your secret key. Remember to switch to your live secret key in production.
# See your keys here: https://dashboard.stripe.com/apikeys
Stripe.api_key = 
'sk_test_BQokikJOvBiI2HlWgH4olfQ2'


post '/retrieve-customer-payment-method' do
  content_type 'application/json'
  data = JSON.parse request.body.read

  payment_method = Stripe::PaymentMethod.retrieve(data['paymentMethodId'])

  payment_method.to_json
end

Exemple de réponse :

{
  "id": "pm_1GcbHY2eZvKYlo2CoqlVxo42",
  "object": "payment_method",
  "billing_details": {
    "address": {
      "city": null,
      "country": null,
      "line1": null,
      "line2": null,
      "postal_code": null,

Remarque

Nous vous recommandons d’enregistrer le paymentMethod.id et les last4 dans votre base de données, par exemple paymentMethod.id dans l’objet stripeCustomerPaymentMethod de votre collection ou table users. Vous pouvez également stocker, si nécessaire : exp_month, exp_year, fingerprint, billing_details. Cela permet de limiter le nombre d’appels effectués vers Stripe, d’optimiser les performances et d’éviter les risques de limite d’appels.

Divulguer Stripe à vos clients

Stripe recueille des informations sur les interactions des clients avec Elements afin de vous fournir des services, de prévenir la fraude et d’améliorer ses services. Cela inclut l’utilisation de cookies et d’adresses IP pour identifier les Elements qu’un client a vus au cours d’une même session Checkout. Vous êtes responsable de la divulgation et de l’obtention de tous les droits et consentements nécessaires pour que Stripe puisse utiliser les données à cette fin. Pour en savoir plus, visitez notre Centre de confidentialité.

Cette page vous a-t-elle été utile ?
OuiNon