Pular para o conteúdo
Criar conta ou Entrar
O logotipo da documentação da Stripe
/
Criar contaLogin
Visão geral
Billing
Visão geralSobre as APIs do Billing
Tributos
Visão geral
Relatórios
Visão geralRelatórios para várias contas
Dados
Visão geral

Crie uma integração de assinaturas

Crie e gerencie assinaturas para aceitar pagamentos recorrentes.

Página de assinatura com valor fixo utilizando o elemento de pagamento
Low-code

Customizar com a API Appearance.

Use este guia para saber como vender assinaturas de preço fixo . você usará o Payment Element com a Checkout Sessions API para criar um formulário de pagamento personalizado que será incorporado à sua inscrição.

Se você não quiser criar um formulário de pagamento personalizado, poderá integrar o checkout hospedado. Para obter uma versão imersiva desse guia de integração de ponta a ponta, consulte o início rápido do Billing .

Se você não estiver pronto para codificar uma integração, pode configurar assinaturas básicas manualmente no Dashboard. Você também pode usar o Payment Links para configurar assinaturas sem precisar escrever nenhum código. Saiba mais sobre como projetar uma integração para entender as decisões que você precisa tomar e os recursos necessários.

O que você vai criar

Este guia ensina a:

  • Modelar seus negócios criando um catálogo de produtos.
  • Construir um processo de registro que cria um cliente.
  • Criar assinaturas e coletar dados de pagamento.
  • Testar e monitorar o status do pagamento e da assinatura.
  • Permitir que os clientes alterem o plano ou cancelem a assinatura.

Definições de objetos de API

RecursoDefinição
ClienteRepresenta um cliente que compra uma assinatura. Use o objeto Customer associado a uma assinatura para fazer e rastrear cobranças recorrentes e para gerenciar os produtos dos quais têm assinatura.
DireitoRepresenta o acesso de um cliente a um recurso incluído em um produto de serviço que assina. Quando você cria uma assinatura para a compra recorrente de um produto por um cliente, um direito ativo é automaticamente criado para cada recurso associado a esse produto. Quando um cliente acessa seus serviços, use os direitos ativos para habilitar os recursos incluídos na assinatura.
RecursoRepresenta uma função ou capacidade que seus clientes podem acessar quando assinam um produto de serviço. Você pode incluir recursos em um produto criando ProductFeatures.
FaturaUma declaração de valores devidos por um cliente que acompanha os status de pagamento desde o esboço até o pagamento (ou outro tipo de finalização). As assinaturas geram faturas automaticamente.
PaymentIntentUma maneira de criar fluxos de pagamentos dinâmicos. Um PaymentIntent acompanha o ciclo de vida do fluxo de checkout de um cliente e aciona etapas adicionais de autenticação quando for exigido por mandatos regulatórios, regras personalizadas contra fraudes do Radar ou formas de pagamento baseadas em redirecionamento. As faturas criam PaymentIntents automaticamente.
PaymentMethodAs formas de pagamento que um cliente usa para pagar seus produtos. Por exemplo, você pode armazenar um cartão de crédito em um objeto Customer e usá-lo para fazer pagamentos recorrentes para esse cliente. Normalmente usado com as APIs Payment Intents ou Setup Intents.
PriceDefine o preço unitário, a moeda e o ciclo de faturamento de um produto.
ProductUm produto ou serviço que sua empresa vende. Um produto de serviço pode incluir um ou mais recursos.
ProductFeatureRepresenta a inclusão de um único recurso em um único produto. Cada produto está associado a um ProductFeature para cada recurso que é incluído, e cada recurso é associado a um ProductFeature para cada produto que o inclui.
SubscriptionRepresenta a compra recorrente agendada de um produto por um cliente. Use uma assinatura para coletar pagamentos e fornecer entregas repetidas ou acesso contínuo a um produto.

Aqui está um exemplo de como produtos, recursos e direitos funcionam juntos. Imagine que você deseja configurar um serviço de assinatura que oferece dois níveis: um produto padrão com funções básicas e um produto avançado que adiciona funções estendidas.

  1. Você cria dois recursos: basic_features e extended_features.
  2. Você cria dois produtos: standard_product e advanced_product.
  3. Para o produto padrão, você cria uma ProductFeature que associa basic_features com standard_product.
  4. Para o produto avançado, você cria duas ProductFeatures: uma que associa basic_features com advanced_product e outra que associa extended_features com advanced_product.

Um cliente, first_customer, assina o produto padrão. Quando você cria a assinatura, a Stripe cria automaticamente um Entitlement que associa first_customer com basic_features.

Outro cliente, second_customer, assina o produto avançado. Quando você cria a assinatura, a Stripe cria automaticamente dois Entitlements: um que associa second_customer a basic_features e outro que associa second_customer com extended_features.

É possível determinar quais recursos fornecer para um cliente recuperando seus direitos ativos ou escutando o evento Active Entitlement Summary. Você não precisa buscar as assinaturas, os produtos e os recursos dele.

Configurar a Stripe

Instale o cliente Stripe de sua escolha:

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'

Em seguida, instale o Stripe CLI. O CLI fornece testes de webhooks, e você pode executá-lo para fazer chamadas de API para a Stripe. Este guia mostra a você como usar o CLI para configurar um modelo de preços em uma seção posterior.

Command Line
homebrew
Instalar da fonte
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

Para obter opções de instalação adicionais, consulte Comece a usar o Stripe CLI.

Criar o modelo de preços
Stripe CLI ou Dashboard

Crie seus produtos e preços usando o Dashboard ou a Stripe CLI.

Este exemplo usa um serviço de preço fixo com duas opções diferentes de nível de serviço: Básico e Premium. Para cada opção de nível de serviço, você precisa criar um produto e um preço recorrente. (Se quiser adicionar uma cobrança avulsa para um item como tarifa de configuração, crie um terceiro produto com um preço avulso. Para simplificar, este exemplo não inclui uma cobrança avulsa.)

Neste exemplo, o faturamento de cada produto é mensal. O produto básico custa 5 USD e o produto Premium custa 15 USD.

Acesse a página Adicionar um produto e crie dois produtos. Adicione um preço para cada produto, cada um com um período de faturamento mensal recorrente:

  • Produto premium: serviço premium com recursos extras

    • Preço: Tarifa fixa | 15 USD

  • Produto básico: serviço básico com recursos mínimos

    • Preço: Tarifa fixa | 5 USD

Depois de criar os preços, registre o ID deles para utilizá-los em outras etapas. Os IDs de preço têm esta estrutura: price_G0FvDp6vZvdwRZ.

Quando tudo estiver pronto, use o botão Copiar para modo de produção, no canto superior direito, para clonar seu produto de uma área restrita para o modo de produção.

Criar o cliente
Cliente e servidor

A Stripe exige um Customer para cada assinatura criada. No front-end da aplicação, colete todas as informações necessárias dos usuários e envie ao servidor.

Se for necessário coletar informações de endereço, o Address Element permite que você colete endereço de entrega ou de cobrança dos seus clientes. Para mais detalhes sobre esse componente, veja a página do 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());

No servidor, crie o objeto Customer da Stripe.

Observação

Certifique-se de armazenar o ID do cliente para utilizá-lo ao iniciar uma sessão de checkout.

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

Criar uma sessão do Checkout
Servidor

No back-end de sua inscrição, defina um endpoint que crie a sessão para ser chamada pelo front-end. você precisará da ID de preço da assinatura na qual o cliente está registrando-se - seu front end passa esse valor.

Se você criou um preço único no passo 2, envie também essa ID de preço. Depois de criar uma Checkout Session, certifique-se de passar o segredo do cliente de volta para o cliente na resposta.

Observação

You can use lookup_keys to fetch prices rather than Price IDs. See the sample application for an example.

Ruby
Python
.NET
PHP
Java
Node.js
Acesse
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

No Dashboard , ative as formas de pagamento que você deseja aceitar de seus clientes. O Checkout aceita várias formas de pagamento.

Inicializar o Checkout
Cliente

Crie um clientSecret como uma promessa (promise) que retorna o segredo do cliente ou defina-o diretamente como o segredo. Em seguida, chame initCheckout, passando o clientSecret. O initCheckout devolve uma promessa que se resolve em uma instância de Checkout.

O objeto checkout representa a estrutura da sua página de checkout e contém os dados da sessão e métodos para atualizações em tempo real.

O objeto retornado por actions.getSession() contém suas informações de preços. Recomendamos a leitura e exibição dototal elineItems da sessão em seu IU.

Isso permite que você ative novos recursos com alterações mínimas no código. Por exemplo, adicionar preços de moedas manualmente não requer alterações na IU se você exibir o 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>

Colete dados de pagamento
Cliente

Colete dados de pagamento no cliente com o Payment Element. O Payment Element é um componente de IU que simplifica a coleta de dados de pagamento para diversas formas de pagamento.

Primeiro, crie um elemento DOM de contêiner para montar o Payment Element. Em seguida, crie uma instância do Payment Element usando checkout.createPaymentElement e monte-a chamando element.mount, fornecendo um seletor CSS ou o elemento DOM do contêiner.

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

Veja as opções disponíveis na documentação da Stripe.js.

Você pode personalizar a aparência de todos os Elements passando elementsOptions.appearance ao inicializar o Checkout no frontend.

Envie o pagamento
Lado do cliente

Renderize um botão Pagar que invoque confirm a partir da instância de Checkout para processar o pagamento.

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;
      }
    });
  });
}

Procuro por webhooks
Servidor

Para concluir a integração, você precisa processar webhooks enviados pela Stripe. Esses eventos são acionados sempre que o status na Stripe muda, como assinaturas que criam novas faturas. No seu aplicativo, configure um manipulador HTTP para aceitar uma solicitação POST contendo o evento webhook e verifique a assinatura do evento:

server.rb
Ruby
Python
PHP
Java
Node.js
Acesse
.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?

Durante o desenvolvimento, use a CLI da Stripe para observar Webhooks e encaminhá-los para sua inscrição. Execute o seguinte em um novo terminal enquanto seu aplicativo de desenvolvimento estiver em execução:

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

Para produção, configure um URL de endpoint de webhook no Dashboard ou use a API Webhook Endpoints.

Você precisa ouvir alguns eventos para concluir as etapas restantes deste guia. Consulte Eventos de assinatura para obter mais detalhes sobre Webhooks específicos de assinatura.

Providenciar acesso ao seu serviço
Cliente e servidor

Agora que a assinatura está ativa, dê ao usuário acesso ao seu serviço. Para fazer isso, ouça os eventos customer.subscription.created, customer.subscription.updated e customer.subscription.deleted. Esses eventos passam um objeto de assinatura que contém um campo status indicando se a assinatura está ativa, vencida ou cancelada. Consulte o ciclo de vida da assinatura para obter uma lista completa de status.

No seu gerenciador de webhooks:

  1. Verifique o status da assinatura. Se estiver active, então o usuário pagou pelo seu produto.
  2. Confira o produto que o cliente assinou e conceda acesso ao serviço. Verificar o produto em vez do preço proporciona mais flexibilidade, caso seja necessário alterar os preços ou o período de faturamento.
  3. Armazene o product.id, subscription.id e subscription.status no seu banco de dados junto com o customer.id que já salvou. Verifique esse registro quando determinar quais recursos precisam ser ativados para o usuário no seu aplicativo.

O status de uma assinatura pode mudar a qualquer momento durante sua existência, mesmo que seu aplicativo não faça chamadas diretas para a Stripe. Por exemplo, uma renovação pode falhar devido a um cartão de crédito expirado, o que coloca a assinatura em um status de vencida. Ou, se você implementar o portal do cliente, um usuário pode cancelar a assinatura sem acessar diretamente seu aplicativo. A implementação correta do manipulador mantém o status do seu aplicativo sincronizado com a Stripe.

Cancelar a assinatura
Cliente e servidor

É comum permitir que os clientes cancelem suas assinaturas. Este exemplo adiciona uma opção de cancelamento à página de configurações da conta.

Exemplo de interface de cancelamento de assinatura.

Configurações da conta com a capacidade de cancelar a assinatura

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.
    });
}

No back-end, configure um endpoint para ser chamado pelo front-end.

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

Seu aplicativo recebe um evento customer.subscription.deleted.

Após o cancelamento da assinatura, atualize seu banco de dados para remover o ID da assinatura do Stripe previamente armazenado e restrinja o acesso ao seu serviço.

Quando uma assinatura é cancelada, você não pode reativá-la. Em vez disso, recolha as informações de faturamento atualizadas do cliente, atualize as formas de pagamento padrão e crie uma nova assinatura com o registro de cliente existente.

Teste a integração

Testar formas de pagamento

Use a tabela a seguir para testar diferentes formas de pagamento e cenários.

Forma de pagamentoCenárioComo testar
Débito automático BECSO cliente paga com débito automático BECS.Preencha o formulário usando o número da conta 900123456 e BSB 000000. O PaymentIntent confirmado inicialmente passa para o status processing, depois passa para succeeded três minutos depois.
Débito automático BECSO pagamento do cliente falha com um código de erro account_closed.Preencha o formulário usando o número da conta 111111113 e BSB 000000.
Cartão de créditoO pagamento com cartão é bem-sucedido e não precisa de autenticação.Preencha o formulário do cartão de crédito usando o número de cartão de crédito 4242 4242 4242 4242 com qualquer validade, CVC e código postal.
Cartão de créditoO pagamento com cartão precisa de autenticação.Preencha o formulário do cartão de crédito usando o número 4000 0025 0000 3155 com qualquer validade, CVC e código postal.
Cartão de créditoO cartão é recusado com um código de recusa como insufficient_funds.Preencha o formulário do cartão de crédito usando o número 4000 0000 0000 9995 com qualquer validade, CVC e código postal.
Débito automático SEPAO cliente paga com débito automático SEPA.Preencha o formulário usando o número de conta AT321904300235473204. Inicialmente, o status do PaymentIntent muda para processing e, três minutos depois, para succeeded.
Débito automático SEPAO status do PaymentIntent do cliente muda de processing para requires_payment_method.Preencha o formulário usando o número de conta AT861904300235473202.

Monitorar eventos

Configure Webhooks para ouvir os eventos de alteração de assinatura, como upgrades e cancelamentos. Saiba mais sobre os Webhooks de assinatura . você pode visualizar eventos no Dashboard ou com o Stripe CLI.

Para obter mais detalhes, consulte testando sua integração com o Billing.

OpcionalPermita que os clientes alterem seus planos
Cliente e servidor

Para permitir que seus clientes alterem assinaturas, obtenha o ID do preço da opção para a qual desejam mudar. Em seguida, envie o ID do novo preço do front-end para um endpoint de back-end. Este exemplo também passa o ID da assinatura, mas é possível acessá-la no seu banco de dados para seu usuário conectado.

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;
    });
}

No back-end, defina o endpoint para a chamada do seu front-end, passando o ID da assinatura e o ID do novo preço. A assinatura agora é Premium, a US$ 15 por mês, em vez de Básica a US$ 5 por mês.

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

Seu aplicativo recebe um evento customer.subscription.updated.

OpcionalPrévia de uma alteração de preço
Cliente e servidor

Quando o cliente altera sua assinatura, geralmente há um ajuste no valor devido, conhecido como pro rata. Você pode usar o endpoint create preview invoice para exibir o valor ajustado aos seus clientes.

No front-end, envie os detalhes da fatura gerada para um endpoint do backend.

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;
    });
}

No back-end, configure um endpoint para ser chamado pelo front-end.

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

OpcionalExibir a forma de pagamento do cliente
Cliente e servidor

Exibir a bandeira e os últimos quatro dígitos do cartão do seu cliente informa qual cartão está sendo cobrado ou se é preciso atualizar a forma de pagamento.

No front-end, envie o ID do método de pagamento para um endpoint de back-end que recupera os detalhes do método de pagamento.

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;
    });
}

No back-end, configure um endpoint para ser chamado pelo front-end.

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

Exemplo de resposta:

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

Observação

Recomendamos que você salve paymentMethod.id e last4 no banco de dados (por exemplo, paymentMethod.id como stripeCustomerPaymentMethodId na coleção ou tabela users). Você também pode armazenar exp_month, exp_year, fingerprint e billing_details conforme necessário. Assim, você reduz o número de chamadas à Stripe para melhorar o desempenho e evitar possíveis limitações de fluxo.

Divulgue a Stripe para seus clientes

A Stripe coleta informações sobre interações do cliente com o Elements para fornecer serviços a você, evitar fraudes e melhorar os serviços. Isso inclui o uso de cookies e endereços IP para identificar quais Elements o cliente visualizou durante uma única sessão de checkout. Você é responsável por divulgar e obter todos os direitos e consentimentos necessários para que a Stripe use os dados dessas maneiras. Para saber mais, acesse nossa central de privacidade.

Esta página foi útil?
SimNão