Última modificação em 6 de outubro de 2020.

O Stripe fornece processamento de pagamentos para oferecer suporte a software de comércio eletrônico e aplicativos móveis. Os principais recursos do Stripe são,

• experiência de pagamento rápida e interativa.
• fluxo de pagamento seguro e tranquilo.
• escopo para elevar a taxa de conversão e o crescimento dos negócios.

Stripe é a solução de gateway de pagamento mais popular que oferece suporte a pagamentos com cartão junto com o PayPal. Sua documentação completa ajuda os desenvolvedores a fazer uma integração sem esforço.

O Stripe oferece diferentes tipos de serviços de pagamento para aceitar pagamentos. Suporta a aceitação de pagamento único, pagamento recorrente, pagamento pessoal e muito mais.

Existem duas maneiras de configurar a opção de pagamento único Stripe em um site de comércio eletrônico.

1. Use a página de check-out hospedada pré-construída segura.
2. Crie um fluxo de pagamento personalizado .

Vamos usar o primeiro método para integrar o pagamento único de Stripe. O código de exemplo redireciona os clientes para a página de checkout hospedada no Stripe. É uma página pré-construída que permite aos clientes inserir detalhes de pagamento.

A opção de finalização de compra hospedada do Stripe pega carona no fator de confiança do Stripe. Se o seu site for menos conhecido, se você não for popular, é melhor escolher esta opção. Porque os usuários finais podem se sentir desconfortáveis ​​ao inserir os detalhes do cartão em sua página.

Este diagrama descreve o fluxo de pagamento Stripe, redirecionamento e tratamento de resposta.

Neste exemplo, ele usa a versão de finalização de compra mais recente para configurar um pagamento único. Se você deseja criar o pagamento de assinatura do Stripe , o artigo vinculado tem um exemplo para isso.

O que há dentro?

1. Sobre o Stripe Checkout
2. Etapas para configurar o fluxo de pagamento único do Stripe
3. Sobre este exemplo
4. Gerar e configurar chaves Stripe API
5. Criar webhook e mapear eventos
6. Bibliotecas necessárias para acessar Stripe API
7. Crie um código cliente-servidor para iniciar o checkout
8. Capture e processe a resposta do webhook
9. Avalie a integração com dados de teste
10. Exemplo de resultado de pagamento único de stripe

Sobre o Stripe Checkout

O último Stripe Checkout oferece uma experiência de checkout tranquila e sem atrito. A lista abaixo mostra alguns recursos da última versão de checkout do Stripe.

• Autenticação forte do cliente (SCA).
• Verifique a fluidez da interface na janela de visualização de vários dispositivos.
• Suporte multilíngue.
• Opções configuráveis ​​para habilitar a coleta de endereços de cobrança, recibos de e-mail e personalizações de botões

Se você estiver usando a versão herdada, é muito simples migrar para a versão mais recente do Stripe Checkout. A versão atualizada oferece suporte a recursos avançados como 3D seguro , pagamentos móveis e muito mais.

Etapas para configurar o fluxo de pagamento único do Stripe

As etapas abaixo são as menos necessárias para configurar um Stripe one-pagamento a prazo online.

1. Registre-se com Stripe e gere chaves API.
2. Configure as chaves de API com o aplicativo.
3. Instale e carregue as bibliotecas necessárias para acessar a API.
4. Crie código do lado do cliente e do servidor para fazer pagamentos.
5. Crie endpoints para receber resposta de pagamento e fazer login em um banco de dados.
6. Crie um modelo de IU para reconhecer os clientes.

Veremos as etapas acima neste artigo com código de exemplo e capturas de tela.

Exemplo de integração de pagamento sobre o Stripe

Stripe API permite que aplicativos acessem e usem seus serviços de pagamento online. Ele fornece uma biblioteca JavaScript ao Stripe.js para iniciar o fluxo da sessão de pagamento.

Este código de exemplo importa as bibliotecas Stripe para acessar as funções da API. Ele define o ponto de extremidade para criar a solicitação e receber a resposta.

O código do lado do cliente e do servidor redireciona os clientes para a página de checkout hospedada no Stripe. Nos gerenciadores de retorno de chamada, ele processa a resposta do pagamento enviada pela API.

Este exemplo usa um banco de dados para armazenar entradas de pagamento. Ele usa MySQLi com instruções preparadas para executar consultas.

Esta imagem mostra a arquitetura de arquivo simples deste exemplo .

Obtenha e configure chaves da API Stripe

Registre-se e faça login no Stripe para obter as chaves API. O painel do Stripe mostrará duas chaves publishable_key e secret_key.

Essas chaves são a referência para validar a solicitação durante o processo de autenticação.

Observação: depois de terminar o teste no modo sandbox, o Stripe exige a ativação da conta para obter as chaves de API ativas.

Este código mostra as constantes criadas para configurar as chaves de API para este exemplo.

 
 Criar webhook e mapear eventos 
 Criar um webhook é uma forma convencional de receber notificações de pagamento enviadas pela API. Todos os provedores de gateway de pagamento oferecem a opção de criar webhook para retorno de chamada. 
 No artigo de  integração do gateway de pagamento do PayPal , vimos os tipos de notificação mecanismos suportados pelo PayPal. 
 O código possui o endpoint do webhook registrado no Stripe. Ele lida com as respostas da API com base no evento ocorrido. 
 A imagem abaixo mostra a captura de tela da caixa de diálogo adicionar endpoint. Ele preenche o URL e os eventos mapeados nos campos do formulário. 
 Navegue por  Developers-> Webhooks  e clique no botão  Adicionar endpoint  para ver a caixa de diálogo. 
    
 Bibliotecas necessárias para acessar a API Stripe 
 Primeiro, baixe e instale a biblioteca  stripe-php . Isso ajudará a enviar uma solicitação de início de pagamento perfeita para a API Stripe. 
 Este comando ajuda a instalar esta biblioteca via Composer. Também está disponível para  download no GitHub.  
 compositor requer stripe/stripe-php

 Carregue a biblioteca JavaScript Stripe.js na página que tem o botão de checkout. Carregue este arquivo usando https://js.stripe.com/v3/em vez de tê-lo no local. 
 

 Criar código cliente-servidor para processar check-out 
 Esta seção inclui as etapas necessárias para criar o código cliente-servidor para configurar o pagamento único Stripe. 


 Adicionar botão de checkout e carregar Stripe.js 
 Crie um manipulador de eventos JavaScript para iniciar a sessão de checkout 
 Crie um endpoint PHP para postar a solicitação de criação de sessão de checkout 
 Redirecionar clientes para a página de pagamento hospedada no Stripe 
 Obtenha a id da sessão de checkout na resposta. 

 Página HTML com botão de checkout Stripe 
 Esta página possui um código HTML para adicionar o botão de checkout do Stripe. Ele carrega a biblioteca Stripe.js. 
 Esta página carrega um JavaScript que inicia a sessão de checkout e redireciona o usuário para o checkout pré-construído do Stripe. 
 O formulário de checkout hospedado do Stripe lida com a validação do cartão de forma eficaz. Criamos um validador de carro personalizado para o código de  integração de pagamento Authorize.net . O checkout hospedado é mais seguro do que lidar com detalhes do cartão por gerenciadores personalizados. 
 index.php 
 






 
 
 Check-out hospedado pré-construído do Stripe 
 
  
 Câmera A6900 MirrorLess 
 
 US $ 289,61 
  Check-out  
 
 



 O manipulador de eventos JavaScript inicia sessão de checkout 
 Na seção anterior, ele carrega um JavaScript para fazer o seguinte. 

 Instancie o objeto da biblioteca Javascript do Stripe com a referência da chave publicável do Stripe. 
 Mapeie o evento de clique do botão de checkout para iniciar uma sessão de criação de checkout. 
 Redirecione os clientes para a página de checkout hospedada no Stripe com a id de sessão de checkout. 

 Ele chama o ponto de extremidade do PHP e constrói os parâmetros de solicitação da API para iniciar uma sessão de checkout. 
 Em seguida, ele recebe o checkout-session-id conforme retornado pelo endpoint do PHP. O método  redirectToCheckout ()  envia os clientes para a finalização da compra pré-construída para concluir o pagamento. 
 Processamento de endpoint de PHP para solicitação de criação de sessão de checkout 
 Ao clicar no botão de checkout, o JavaScript executa uma solicitação AJAX. Ele busca o endpoint do PHP processando a solicitação de criação de sessão de checkout. 
 O código a seguir mostra como criar a sessão de checkout do Stripe via API. A solicitação da API está com os parâmetros de consulta necessários. Inclui os detalhes do produto, valor unitário, método de pagamento e muito mais. 
 Então, a API retornará o objeto de sessão após processar esta solicitação. Este endpoint analisa a resposta e pega o id da sessão e o retorna. 
 ajax-endpoint/create-checkout-session.php 
  insertOrder (Config:: PRODUCT_PRICE, $ currency, $ orderReferenceId,"Pagamento em andamento");
$ unitAmount=Config:: PRODUCT_PRICE * 100;
$ session=$ stripeService-> createCheckoutSession ($ unitAmount, $ orderId);
echo json_encode ($ sessão);

 O StripeService é uma classe PHP criada para construir solicitações de API e processar respostas. 
 A função createCheckoutSession () constrói a matriz param para a solicitação create-checkout-session. 
 Este serviço também lida com as respostas do webhook enviadas pela API. A API envia a resposta nas ocorrências dos eventos mapeados com a URL do endpoint do webhook. 
 lib/StripeService.php 
  ['cartão'], 'line_items'=> [[ 'price_data'=> [ 'moeda'=> Config:: CURRENCY, 'unit_amount'=> $ unitAmount, 'product_data'=> [ 'name'=> Config:: PRODUCT_NAME, 'imagens'=> [Config:: PRODUCT_IMAGE], ], ], 'quantidade'=> 1, ]], 'modo'=>'pagamento', 'client_reference_id'=> $ clientReferenceId, 'success_url'=> Config:: ROOT_PATH.'/success.php?session_id={CHECKOUT_SESSION_ID}', 'cancel_url'=> Config:: ROOT_PATH.'/index.php?status=cancel', ]); return $ checkout_session; } public function captureResponse () { $ payload=@file_get_contents ('php://input'); $ event=json_decode ($ carga útil); require_once __DIR__."/../lib/StripePayment.php"; $ stripePayment=new StripePayment (); switch ($ event-> type) { case"customer.created": $ param ["stripe_customer_id"]=$ evento-> dados-> objeto-> id; $ param ["email"]=$ event-> data-> object-> email; $ param ["customer_created_datetime"]=data ("S, m, d H: i: s", $ evento-> dados-> objeto-> criado); $ param ["stripe_response"]=json_encode ($ evento-> dados-> objeto); $ stripePayment-> insertCustomer ($ param); pausa; case"checkout.session.completed": $ param ["order_id"]=$ event-> data-> object-> client_reference_id; $ param ["customer_id"]=$ event-> data-> object-> customer; $ param ["payment_intent_id"]=$ evento-> dados-> objeto-> pagamento_intent; $ param ["stripe_checkout_response"]=json_encode ($ event-> data-> object); $ stripePayment-> updateOrder ($ param); pausa; case"payment_intent.created": $ param ["payment_intent_id"]=$ evento-> dados-> objeto-> id; $ param ["payment_create_at"]=data ("A-m-d H: i: s", $ evento-> dados-> objeto-> criado); $ param ["payment_status"]=$ event-> data-> object-> status; $ param ["stripe_payment_response"]=json_encode ($ event-> data-> object); $ stripePayment-> insertPayment ($ param); pausa; case"payment_intent.succeeded": $ param ["payment_intent_id"]=$ evento-> dados-> objeto-> id; $ param ["billing_name"]=$ evento-> dados-> objeto-> encargos-> dados [0]-> faturamento_details-> nome; $ param ["billing_email"]=$ evento-> dados-> objeto-> encargos-> dados [0]-> billing_details-> email; $ param ["payment_last_updated"]=data ("Y-m-d H: i: s", $ evento-> dados-> objeto-> encargos-> dados [0]-> criado); $ param ["status_pagamento"]=$ evento-> dados-> objeto-> cobranças-> dados [0]-> status; $ param ["stripe_payment_response"]=json_encode ($ event-> data-> object); $ stripePayment-> updatePayment ($ param); pausa; case"payment_intent.canceled": $ param ["payment_intent_id"]=$ evento-> dados-> objeto-> id; $ param ["billing_name"]=$ evento-> dados-> objeto-> encargos-> dados [0]-> faturamento_details-> nome; $ param ["billing_email"]=$ evento-> dados-> objeto-> encargos-> dados [0]-> faturamento_details-> email; $ param ["payment_last_updated"]=data ("Y-m-d H: i: s", $ evento-> dados-> objeto-> encargos-> dados [0]-> criado); $ param ["status_pagamento"]=$ evento-> dados-> objeto-> cobranças-> dados [0]-> status; $ param ["stripe_payment_response"]=json_encode ($ event-> data-> object); $ stripePayment-> updatePayment ($ param); pausa; case"payment_intent.payment_failed": $ param ["payment_intent_id"]=$ evento-> dados-> objeto-> id; $ param ["billing_name"]=$ evento-> dados-> objeto-> encargos-> dados [0]-> faturamento_details-> nome; $ param ["billing_email"]=$ evento-> dados-> objeto-> despesas-> dados [0]-> faturamento_details-> email; $ param ["payment_last_updated"]=data ("Y-m-d H: i: s", $ evento-> dados-> objeto-> encargos-> dados [0]-> criado); $ param ["status_pagamento"]=$ evento-> dados-> objeto-> cobranças-> dados [0]-> status; $ param ["stripe_payment_response"]=json_encode ($ event-> data-> object); $ stripePayment-> updatePayment ($ param); pausa; } http_response_code (200); }
} 
 Capture e processe a resposta 
 O arquivo  capture-response.php  chama a classe StripeService para lidar com a resposta do webhook. 
 O endpoint de webhook registrado possui o mapeamento para os eventos. A figura mostra os eventos mapeados e o URL do webhook abaixo. 
  
 A função captureResponse () trata a resposta da API com base nos eventos que ocorreram. 
 Em cada evento, ele atualiza as tabelas do banco de dados de pedidos do cliente. Ele cria o registro de resposta de pagamento para colocar entradas na tabela tbl_stripe_response. 
 webhook-ep/capture-response.php 
  captureResponse (); ?>

 Ele invoca a função captureResponse () do StripeService. Ele chama StripePayment para armazenar pedidos, clientes e dados de pagamento no banco de dados. 
 A classe StripePayment usa DataSource para conectar o banco de dados e acessá-lo. 
 lib/StripePayment.php 
  ds=new DataSource (); } função pública insertOrder ($ unitAmount, $ currency, $ orderReferenceId, $ orderStatus) { $ orderAt=date ("A-m-d H: i: s"); $ insertQuery="INSERT INTO tbl_order (order_reference_id, quantidade, moeda, order_at, order_status) VALUES (?,?,?,?,?)"; $ paramValue=array ( $ orderReferenceId, $ unitAmount, $ moeda, $ orderAt, $ orderStatus ); $ paramType="sisss"; $ insertId=$ this-> ds-> insert ($ insertQuery, $ paramType, $ paramValue); return $ insertId; } public function updateOrder ($ param) { $ paymentDetails=$ this-> getPaymentByIntent ($ param ["payment_intent_id"]); if (! empty ($ paymentDetails)) { if ($ paymentDetails [0] ["payment_status"]=="bem-sucedido") { $ paymentStatus="Pago"; } else if ($ paymentDetails [0] ["payment_status"]=="requer_source") { $ paymentStatus="Pagamento em andamento"; } $ query="UPDATE tbl_order SET stripe_customer_id=?, stripe_payment_intent_id=?, stripe_checkout_response=?, order_status=? WHERE id=?"; $ paramValue=array ( $ param ["customer_id"], $ param ["payment_intent_id"], $ param ["stripe_checkout_response"], $ paymentStatus, $ param ["order_id"] ); $ paramType="ssssi"; $ this-> ds-> execute ($ query, $ paramType, $ paramValue); } } public function insertCustomer ($ customer) { $ insertQuery="INSERT INTO tbl_customer (stripe_customer_id, email, customer_created_datetime, stripe_response) VALORES (?,?,?,?)"; $ paramValue=array ( $ customer ["stripe_customer_id"], $ customer ["email"], $ customer ["customer_created_datetime"], $ customer ["stripe_response"] ); $ paramType="ssss"; $ this-> ds-> insert ($ insertQuery, $ paramType, $ paramValue); } função pública insertPayment ($ param) { $ insertQuery="INSERT INTO tbl_payment (stripe_payment_intent_id, payment_create_at, payment_status, stripe_payment_response) VALUES (?,?,?,?)"; $ paramValue=array ( $ param ["payment_intent_id"], $ param ["payment_create_at"], $ param ["payment_status"], $ param ["stripe_payment_response"] ); $ paramType="ssss"; $ this-> ds-> insert ($ insertQuery, $ paramType, $ paramValue); } public function updatePayment ($ param) { $ query="UPDATE tbl_payment SET billing_name=?, billing_email=?, payment_last_updated=?, payment_status=?, stripe_payment_response=? WHERE stripe_payment_intent_id=?"; $ paramValue=array ( $ param ["billing_name"], $ param ["billing_email"], $ param ["payment_last_updated"], $ param ["payment_status"], $ param ["stripe_payment_response"], $ param ["payment_intent_id"] ); $ paramType="ssssss"; $ this-> ds-> execute ($ query, $ paramType, $ paramValue); } public function getPaymentByIntent ($ paymentIntent) { $ query="SELECT * FROM tbl_payment WHERE stripe_payment_intent_id=?"; $ paramValue=array ( $ paymentIntent ); $ paramType="s"; $ result=$ this-> ds-> select ($ query, $ paramType, $ paramValue); return $ result; }
}
?>

 Mostrando página de sucesso após o pagamento 
 Conforme enviado com a solicitação de criação de sessão de checkout, Stripe invoca o URL da página de sucesso após o pagamento. 
 O código abaixo contém a mensagem de sucesso do pagamento para reconhecer os clientes. 
 success.php 
 





 
 
 Obrigado por comprar conosco. 
 
 Você comprou""com sucesso. 
 
 Você foi notificado sobre o status de pagamento do seu compre em breve. 
 



 Script de banco de dados 
 Importe o seguinte script SQL para executar este exemplo em seu ambiente. Ele tem o SQL para criar tabelas criadas para este exemplo e para construir um relacionamento entre elas. 
 sql/structure.sql 
-
-Estrutura da tabela para a tabela `tbl_customer`
- CRIAR TABELA `tbl_customer` ( `id` int (11) NÃO NULO, `stripe_customer_id` varchar (255) NÃO NULO, `email` varchar (50) NÃO NULO, timestamp `customer_created_datetime` NOT NULL DEFAULT CURRENT_TIMESTAMP NA ATUALIZAÇÃO CURRENT_TIMESTAMP, texto `stripe_response` NÃO NULO, carimbo de data/hora `create_at` NOT NULL DEFAULT CURRENT_TIMESTAMP NA ATUALIZAÇÃO CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=latin1; --------------------------------------------------------- -
-Estrutura da tabela para a tabela `tbl_order`
- CRIAR TABELA `tbl_order` ( `id` int (11) NÃO NULO, `order_reference_id` varchar (255) NOT NULL, `stripe_customer_id` varchar (255) DEFAULT NULL, `stripe_payment_intent_id` varchar (255) DEFAULT NULL, `quantidade` decimal (10,2) NÃO NULO, `moeda` varchar (10) NÃO NULO, timestamp `order_at` NOT NULL DEFAULT CURRENT_TIMESTAMP NA ATUALIZAÇÃO CURRENT_TIMESTAMP, `order_status` varchar (25) NÃO NULO, texto `stripe_checkout_response` NÃO NULO, carimbo de data/hora `create_at` NOT NULL DEFAULT CURRENT_TIMESTAMP NA ATUALIZAÇÃO CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=latin1; --------------------------------------------------------- -
-Estrutura da tabela para a tabela `tbl_payment`
- CRIAR TABELA `tbl_payment` ( `id` int (11) NÃO NULO, `stripe_payment_intent_id` varchar (255) NÃO NULO, carimbo de data/hora `payment_create_at` NULL DEFAULT NULL, timestamp `payment_last_updated` NULL DEFAULT'0000-00-00 00:00:00', `billing_name` varchar (255) NÃO NULO, `billing_email` varchar (255) NÃO NULO, `status_pagamento` varchar (255) NÃO NULO, texto `stripe_payment_response` NÃO NULO, carimbo de data/hora `create_at` NOT NULL DEFAULT CURRENT_TIMESTAMP NA ATUALIZAÇÃO CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=latin1; -
-Índices para tabelas despejadas
- -
-Índices para a tabela `tbl_customer`
-
ALTER TABLE `tbl_customer` ADICIONE CHAVE PRIMÁRIA (`id`), ADICIONE CHAVE ÚNICA `stripe_customer_id` (` stripe_customer_id`); -
-Índices para a tabela `tbl_order`
-
ALTER TABLE `tbl_order` ADICIONE CHAVE PRIMÁRIA (`id`), ADICIONE CHAVE `stripe_payment_intent_id` (` stripe_payment_intent_id`), ADICIONE CHAVE `stripe_customer_id` (` stripe_customer_id`); -
-Índices para a tabela `tbl_payment`
-
ALTER TABLE `tbl_payment` ADICIONE CHAVE PRIMÁRIA (`id`), ADICIONE CHAVE ÚNICA `stripe_payment_intent_id` (` stripe_payment_intent_id`); -
-AUTO_INCREMENT para tabelas despejadas
- -
-AUTO_INCREMENT para a tabela `tbl_customer`
-
ALTER TABLE `tbl_customer` MODIFY `id` int (11) NOT NULL AUTO_INCREMENT; -
-AUTO_INCREMENT para a tabela `tbl_order`
-
ALTER TABLE `tbl_order` MODIFY `id` int (11) NOT NULL AUTO_INCREMENT; -
-AUTO_INCREMENT para a tabela `tbl_payment`
-
ALTER TABLE `tbl_payment` MODIFY `id` int (11) NOT NULL AUTO_INCREMENT; -
-Restrições para tabelas despejadas
- -
-Restrições para a tabela `tbl_order`
-
ALTER TABLE `tbl_order` ADICIONE CONSTRAINT `tbl_order_ibfk_1` FOREIGN KEY (` stripe_payment_intent_id`) REFERÊNCIAS `tbl_payment` (` stripe_payment_intent_id`), ADICIONE CONSTRAINT `tbl_order_ibfk_2` FOREIGN KEY (` stripe_customer_id`) REFERÊNCIAS `tbl_customer` (` stripe_customer_id`);
COMMIT;

 Avalie a integração com dados de teste 
 Depois de integrar o pagamento único do Stripe, avalie a integração com os detalhes do cartão de teste. 
 Os seguintes detalhes do cartão de teste ajudam a tentar um fluxo de pagamento bem-sucedido. 



 Número do cartão 
 4242424242424242 


 Mês/ano de expiração 
 Qualquer data futura 


 CVV 
 Número de três dígitos 



 O Stripe fornece mais  detalhes do cartão de teste  para receber mais tipos de respostas. 
 Exemplo de saída de pagamento único de stripe 
 Este exemplo exibe um bloco de produto com o botão Stripe Checkout, conforme mostrado abaixo. 
  
 Ao clicar no botão Checkout, ele redireciona os clientes para a página pré-construída de checkout hospedada no Stripe. 
  
 Depois de processar o pagamento, Stripe redirecionará os clientes para o URL da página de sucesso. 
  
 Conclusão 
 Vimos como integrar o checkout hospedado stripe em PHP com um exemplo. Espero que seja simples e fácil de seguir. 
 É útil ter uma visão rápida dos itens, pré-requisitos e etapas de implementação. Ele identifica os itens de tarefas em resumo. 
 O código-fonte disponível para download contém os arquivos do fornecedor necessários. Não é necessário baixar bibliotecas e SDK de qualquer lugar. 
 Com a intervenção do banco de dados, o código está pronto para ser integrado a um aplicativo completo. 
 Com a última versão de checkout do Stripe, ele fornece serviços de pagamento com SCA e recursos mais avançados. 
  Download  
  

 Artigos populares 


 ↑ Voltar ao topo 

Source link