# Integrar com a API Invoicing Saiba como criar e enviar uma fatura com código. O [Dashboard](https://dashboard.stripe.com/invoices) é o caminho mais comum para [criar faturas](https://docs.stripe.com/invoicing/dashboard.md#create-invoice). Se quiser automatizar a criação de faturas, você pode integrar a API. Crie uma integração completa e operacional do Invoicing usando o [exemplo de integração](https://docs.stripe.com/invoicing/integration/quickstart.md). ## Configurar a Stripe Use nossas bibliotecas oficiais para acessar a API Stripe: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ## Criar um produto Para criar um produto, informe o nome dele: ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ -d name="Gold Special" ``` ## Criar um preço [Preços](https://docs.stripe.com/api.md#prices) definem quanto e com que frequência cobrar os produtos. Você define o custo do produto, a moeda a ser usada e o intervalo de cobrança (quando o preço refere-se a uma assinatura). Assim como os produtos, se você tem poucos preços, é preferível gerenciá-los no Dashboard. Use o valor unitário para expressar preços na menor unidade da moeda, neste caso, centavos (10 USD são 1.000 centavos, portanto, o valor unitário é 1000). Se não for preciso criar um preço para seu produto, você também pode usar o parâmetro [value](https://docs.stripe.com/api/invoiceitems/create.md#create_invoiceitem-amount) durante a criação do item da fatura. Para criar um preço e atribuí-lo ao produto, passe o ID, o valor unitário e a moeda do produto. Neste exemplo, o preço do produto “Gold Special” é US$ 10: ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d product="{{PRODUCT_ID}}" \ -d unit_amount=1000 \ -d currency=usd ``` ## Criar um cliente O objeto [Customer](https://docs.stripe.com/api.md#customer_object) representa o cliente que compra seu produto e é obrigatório para criar uma fatura. Para [criar um cliente](https://docs.stripe.com/api/customers/create.md) com um `nome`, `e-mail` e `descrição`, adicione o seguinte código substituindo os valores pelos seus próprios: ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ -d name="Jenny Rosen" \ --data-urlencode email="jenny.rosen@example.com" \ -d description="My first customer" ``` Após criar o cliente, armazene o `id` do cliente no seu banco de dados para usá-lo mais tarde. A próxima etapa, por exemplo, usa o ID do cliente para criar uma fatura. ## Criar uma fatura Defina o atributo [collection_method](https://docs.stripe.com/api/invoices/object.md#invoice_object-collection_method) como `send_invoice`. Para a Stripe marcar uma fatura como vencida, é preciso adicionar o parâmetro [days_until_due](https://docs.stripe.com/api/invoices/create.md#create_invoice-days_until_due). Quando você envia uma fatura, a Stripe envia ao cliente um e-mail com instruções de pagamento. ```curl curl https://api.stripe.com/v1/invoices \ -u "<>:" \ -d customer="{{CUSTOMER_ID}}" \ -d collection_method=send_invoice \ -d days_until_due=30 ``` Em seguida, crie um item de fatura passando um `id` de cliente, um `price` de produto e um ID de fatura `invoice`. Adicione itens de fatura a um único cliente por vez para evitar adicioná-los ao cliente errado. O número máximo de itens da fatura é 250. ```curl curl https://api.stripe.com/v1/invoiceitems \ -u "<>:" \ -d customer="{{CUSTOMER_ID}}" \ -d "pricing[price]"="{{PRICE_ID}}" \ -d invoice="{{INVOICE_ID}}" ``` Se você definir `auto_advance` como `false`, continue a modificar a fatura até [finalizá-la](https://docs.stripe.com/invoicing/integration/workflow-transitions.md). Para finalizar uma fatura provisória, use o Dashboard para pagá-la ou enviá-la ao cliente. Também é possível usar a API [Finalize](https://docs.stripe.com/api/invoices/finalize.md): ```curl curl -X POST https://api.stripe.com/v1/invoices/{{INVOICE_ID}}/finalize \ -u "<>:" ``` Se você criar uma fatura por engano, [anule-a](https://docs.stripe.com/invoicing/overview.md#void). Também é possível marcar uma fatura como [incobrável](https://docs.stripe.com/invoicing/overview.md#uncollectible). ## Aceite pagamento de faturas #### Envie uma fatura Envie a fatura para o endereço de e-mail associado ao cliente. A Stripe finaliza a fatura assim que você a envia. Muitas jurisdições consideram as faturas finalizadas um documento legal, o que impede a alteração de alguns campos. Quando você envia faturas que já foram pagas, não há referência ao pagamento no e-mail. > Quando você envia faturas que já foram pagas, o e-mail não faz referência ao pagamento. A Stripe envia faturas para o e-mail associado ao cliente. ```curl curl -X POST https://api.stripe.com/v1/invoices/{{INVOICE_ID}}/send \ -u "<>:" ``` #### Stripe Elements Quando a fatura é finalizada, um *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) é gerado e associado à fatura. Use o [Stripe Elements](https://docs.stripe.com/payments/elements.md) para coletar dados de pagamento e confirmar o PaymentIntent da fatura. Não é possível editar valores monetários ou o parâmetro `collection_method` após a finalização de uma fatura. Essa restrição também se aplica ao PaymentIntent da fatura finalizada. Quando você atualiza o PaymentIntent de uma fatura com uma chamada de [atualização](https://docs.stripe.com/api/payment_intents/update.md), só é possível modificar os parâmetros `setup_future_usage`, `metadata`, `payment_method`, `description`, `receipt_email`, `payment_method_data`, `payment_method_options` e `shipping` #### Payment Element (recomendado) O [Payment Element](https://docs.stripe.com/payments/payment-element.md) coleta com segurança todos os dados de pagamento necessários para diversas formas de pagamento. Consulte [Suporte a formas de pagamento e produtos](https://docs.stripe.com/payments/payment-methods/payment-method-support.md) para determinar se as formas de pagamento configuradas são aceitas pelo Invoicing e pelo Payment Element. ### Passe o segredo do cliente para o front-end O Stripe.js usa o [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) do PaymentIntent para concluir o processo de pagamento com segurança. Obtenha o segredo do cliente da fatura [expandindo](https://docs.stripe.com/api/expanding_objects.md) o atributo [confirmation_secret](https://docs.stripe.com/api/invoices/object.md#invoice_object-confirmation_secret) ao [finalizar](https://docs.stripe.com/api/invoices/finalize.md) a fatura ou ao fazer outra chamada de API, como [retrieve](https://docs.stripe.com/api/invoices/retrieve.md) ou [update](https://docs.stripe.com/api/invoices/update.md) para a fatura após finalizá-la. Retorne o `client_secret` para o frontend para concluir o pagamento. ```curl curl https://api.stripe.com/v1/invoices/{{INVOICE_ID}}/finalize \ -u "<>:" \ -d "expand[]"=confirmation_secret ``` Após o retorno da fatura, acesse o segredo do cliente no campo `confirmation_secret` expandido. #### curl #### Stripe CLI #### Rubi ```ruby client_secret = invoice.confirmation_secret.client_secret ``` #### Python ```python client_secret = invoice.confirmation_secret.client_secret ``` #### PHP ```php $client_secret = $invoice->confirmation_secret->client_secret; ``` #### Java ```java String clientSecret = invoice.getConfirmationSecret().getClientSecret(); ``` #### Node.js ```javascript const client_secret = invoice.confirmation_secret.client_secret; ``` #### Ir ```go clientSecret := invoice.ConfirmationSecret.ClientSecret, ``` #### .NET ```csharp var clientSecret = invoice.ConfirmationSecret.ClientSecret; ``` ### Configurar o Stripe Elements O Payment Element está disponível automaticamente como um recurso do Stripe.js. Inclua o script do Stripe.js em sua página de checkout adicionando-o ao `head` do arquivo HTML. Sempre carregue Stripe.js diretamente de js.stripe.com para manter a conformidade com PCI. Não inclua o script em um pacote nem hospede você mesmo uma cópia dele. ```html Pay Invoice ``` Crie uma instância da Stripe com o seguinte JavaScript na sua página de checkout: ```javascript // Set your publishable key: remember to change this to your live publishable key in production // See your keys here: https://dashboard.stripe.com/apikeys const stripe = Stripe('<>'); ``` ### Adicione o Element Pagamento à sua página O Payment Element precisa de um lugar para residir na sua página de pagamentos. Crie um nó DOM vazio (contêiner) com um ID único no seu formulário de pagamento. ```html
``` Quando o formulário for carregado, crie uma instância do Payment Element e monte-a no node DOM do contêiner. Passe o segredo do cliente do PaymentIntent como opção ao criar uma instância do Elements. ```javascript const options = { clientSecret: '{{CLIENT_SECRET}}', // Fully customizable with appearance API. appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in your checkout form, passing in the client secret. const elements = stripe.elements(options); // Create and mount the Payment Element const paymentElementOptions = { layout: 'accordion'}; const paymentElement = elements.create('payment', paymentElementOptions); paymentElement.mount('#payment-element'); ``` O Payment Element renderiza um formulário dinâmico que permite ao cliente escolher uma forma de pagamento. O formulário coleta automaticamente todos os dados de pagamento necessários para a forma de pagamento selecionada pelo cliente. Você pode personalizar o Payment Element para corresponder ao design do seu site, passando o [objeto appearance](https://docs.stripe.com/elements/appearance-api.md) em `options` ao criar uma instância do Elements. ### Finalizar pagamento Use `stripe.confirmPayment` para concluir o pagamento usando os detalhes do Payment Element. Isso cria uma forma de pagamento e confirma o PaymentIntent da fatura, fazendo com que uma cobrança seja feita. Se a *Autenticação forte de cliente* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) (SCA) for necessária para o pagamento, o Payment Element gerenciará o processo de autenticação antes de confirmar o PaymentIntent. Forneça um [return_url](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-return_url) à função `confirmPayment` para indicar para onde a Stripe deve redirecionar o usuário após a conclusão do pagamento. Seu usuário pode ser redirecionado primeiro para um site intermediário, como uma página de autorização bancária, antes de ser redirecionado para o `return_url`. Os pagamentos por cartão são redirecionados imediatamente para o `return_url` quando um pagamento é bem-sucedido. ```javascript const form = document.getElementById('payment-form'); form.addEventListener('submit', async (event) => { event.preventDefault(); const {error} = await stripe.confirmPayment({ //`Elements` instance that was used to create the Payment Element elements, confirmParams: { return_url: "https://example.com/order/123/complete", } }); if (error) { // This point will only be reached if there is an immediate error when // confirming the payment. Show error to your customer (for example, payment // details incomplete) const messageContainer = document.querySelector('#error-message'); messageContainer.textContent = error.message; } else { // Your customer will be redirected to your `return_url`. For some payment // methods like iDEAL, your customer will be redirected to an intermediate // site first to authorize the payment, then redirected to the `return_url`. } }); ``` Quando o cliente envia um pagamento, a Stripe o redireciona para o `return_url` e inclui os parâmetros de consulta de URL a seguir. A página de retorno pode usá-los para obter o status do PaymentIntent e exibir o status do pagamento para o cliente. Ao especificar o `return_url`, você também pode anexar seus próprios parâmetros de consulta para uso na página de retorno. | Parâmetro | Descrição | | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `payment_intent` | O identificador único do `PaymentIntent`. | | `payment_intent_client_secret` | O [segredo do cliente](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) do objeto `PaymentIntent`. Para integrações de assinaturas, esse client_secret também é exposto no objeto `Invoice` por meio de [`confirmation_secret`](https://docs.stripe.com/api/invoices/object.md#invoice_object-confirmation_secret) | Quando o cliente é redirecionado para o seu site, você pode usar o `payment_intent_client_secret` para consultar o PaymentIntent e exibir o status da transação ao cliente. > Se você tiver ferramentas que rastreiam a sessão do cliente no navegador, pode ser necessário adicionar o domínio `stripe.com` à lista de exclusão de referenciadores. Os redirecionamentos fazem com que algumas ferramentas criem novas sessões, o que impede que você rastreie a sessão completa. Use o parâmetro de consulta `payment_intent_client_secret` para recuperar o PaymentIntent. Inspecione o [status do PaymentIntent](https://docs.stripe.com/payments/paymentintents/lifecycle.md) para decidir o que mostrar aos seus clientes. Você também pode anexar seus próprios parâmetros de consulta ao fornecer o `return_url`, que persiste durante o processo de redirecionamento. ```javascript // Initialize Stripe.js using your publishable key const stripe = Stripe('<>'); // Retrieve the "payment_intent_client_secret" query parameter appended to // your return_url by Stripe.js const clientSecret = new URLSearchParams(window.location.search).get( 'payment_intent_client_secret' ); // Retrieve the PaymentIntent stripe.retrievePaymentIntent(clientSecret).then(({paymentIntent}) => { const message = document.querySelector('#message') // Inspect the PaymentIntent `status` to indicate the status of the payment // to your customer. // // Some payment methods will [immediately succeed or fail][0] upon // confirmation, while others will first enter a `processing` state. // // [0]: https://stripe.com/docs/payments/payment-methods#payment-notification switch (paymentIntent.status) { case 'succeeded': message.innerText = 'Success! Payment received.'; break; case 'processing': message.innerText = "Payment processing. We'll update you when payment is received."; break; case 'requires_payment_method': message.innerText = 'Payment failed. Please try another payment method.'; // Redirect your user back to your payment page to attempt collecting // payment again break; default: message.innerText = 'Something went wrong.'; break; } }); ``` #### Card Element O Element Cartão coleta e valida com segurança dados de cartão de crédito do seu usuário. ### Passe o segredo do cliente para o front-end O Stripe.js usa o [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) do PaymentIntent para concluir o processo de pagamento com segurança. Obtenha o segredo do cliente da fatura [expandindo](https://docs.stripe.com/api/expanding_objects.md) o atributo [confirmation_secret](https://docs.stripe.com/api/invoices/object.md#invoice_object-confirmation_secret) ao [finalizar](https://docs.stripe.com/api/invoices/finalize.md) a fatura ou ao fazer outra chamada de API, como [retrieve](https://docs.stripe.com/api/invoices/retrieve.md) ou [update](https://docs.stripe.com/api/invoices/update.md) para a fatura após finalizá-la. Retorne o `client_secret` para o frontend para concluir o pagamento. ```curl curl https://api.stripe.com/v1/invoices/{{INVOICE_ID}}/finalize \ -u "<>:" \ -d "expand[]"=confirmation_secret ``` Após o retorno da fatura, acesse o segredo do cliente no campo `confirmation_secret` expandido. #### curl #### Stripe CLI #### Rubi ```ruby client_secret = invoice.confirmation_secret.client_secret ``` #### Python ```python client_secret = invoice.confirmation_secret.client_secret ``` #### PHP ```php $client_secret = $invoice->confirmation_secret->client_secret; ``` #### Java ```java String clientSecret = invoice.getConfirmationSecret().getClientSecret(); ``` #### Node.js ```javascript const client_secret = invoice.confirmation_secret.client_secret; ``` #### Ir ```go clientSecret := invoice.ConfirmationSecret.ClientSecret, ``` #### .NET ```csharp var clientSecret = invoice.ConfirmationSecret.ClientSecret; ``` ### Configurar o Stripe Elements O Stripe Elements está incluído com o Stripe.js. Inclua o script do Stripe.js na sua página de checkout adicionando-o ao `head` do seu arquivo HTML. Sempre carregue o Stripe.js diretamente de js.stripe.com para manter a conformidade com PCI. Não insira o script em um pacote nem hospede sua própria cópia. ```html Subscription prices ``` Crie uma instância do Elements com o seguinte JavaScript: ```javascript // Set your publishable key: remember to change this to your live publishable key in production // See your keys here: https://dashboard.stripe.com/apikeys let stripe = Stripe('<>'); let elements = stripe.elements(); ``` ### Adicione o Elements à sua página O Elements precisa de um lugar específico em seu formulário de pagamentos. Crie nodes de DOM vazios (contêineres) com IDs individuais no formulário de pagamento e envie os IDs para o Elements. ```html
``` Crie uma instância de um Element e monte-a no contêiner do Element: ```javascript let card = elements.create('card', { style: style }); card.mount('#card-element'); ``` O elemento `card` simplifica o formulário e minimiza o número de campos necessários, inserindo um único campo de entrada flexível que coleta com segurança todos os dados necessários do cartão. Para obter uma lista completa dos tipos de elementos aceitos, consulte a [documentação de referência do Stripe.js](https://docs.stripe.com/js.md#elements_create). Use o número de cartão de teste **4242 4242 4242 4242**, qualquer número de CVC de três dígitos, qualquer data de validade futura e qualquer código postal de cinco dígitos. O Elements valida as inserções do usuário conforme são digitadas. Para ajudar os clientes a reconhecer erros, monitore os eventos de `change` no `card` Element e exiba quaisquer mensagens de erro. ```javascript card.on('change', function (event) { displayError(event); }); function displayError(event) { changeLoadingStatePrices(false); let displayError = document.getElementById('card-element-errors'); if (event.error) { displayError.textContent = event.error.message; } else { displayError.textContent = ''; } } ``` A [validação de código postal](https://docs.stripe.com/js.md#postal-code-formatting) depende do país onde o cliente é faturado. Use nossos [cartões internacionais de teste](https://docs.stripe.com/testing.md#international-cards) para testar outros formatos de código postal. ### Finalizar pagamento Quando seu cliente enviar o formulário do Elements, chame `stripe.confirmCardPayment` com o *segredo do cliente* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) que você passou para o seu front-end. Isso cria uma forma de pagamento e *confirma* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) o PaymentIntent da fatura, fazendo com que uma cobrança seja feita. Se a *Autenticação forte de cliente* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) (SCA) for necessária para o pagamento, o Elements gerencia o processo de autenticação antes de confirmar o PaymentIntent. ```javascript const btn = document.querySelector('#submit-payment-btn'); btn.addEventListener('click', async (e) => { e.preventDefault(); const nameInput = document.getElementById('name'); // Create payment method and confirm PaymentIntent. stripe.confirmCardPayment(clientSecret, { payment_method: { card: cardElement, billing_details: { name: nameInput.value, }, } }).then((result) => { if(result.error) { alert(result.error.message); } else { // Successful invoice payment } }); }); ``` ## Gerenciar eventos pós-pagamento A Stripe envia um evento [invoice.paid](https://docs.stripe.com/api/events/types.md?event_types-invoice.paid) quando o pagamento de uma fatura é concluído. Ouça este evento para garantir um execução confiável. Se a sua integração depender apenas de um retorno de chamada no lado do cliente, o cliente poderá perder a conexão antes que o retorno de chamada seja executado, o que faria com que o cliente fosse cobrado sem que seu servidor fosse notificado. Configurar a integração para ouvir eventos assíncronos também permite aceitar [diferentes formas de pagamento](https://stripe.com/payments/payment-methods-guide) com uma única integração. Os pagamentos de faturas bem-sucedidos acionam os eventos [invoice.paid](https://docs.stripe.com/api/events/types.md?event_types-invoice.paid) e [invoice.payment_succeeded](https://docs.stripe.com/api/events/types.md?event_types-invoice.payment_succeeded). Ambos os tipos de evento contêm os mesmos dados da fatura, portanto, você só precisa prestar atenção a um deles para ser notificado sobre os pagamentos de faturas bem-sucedidos. A diferença é que os eventos `invoice.payment_succeeded` são enviados para pagamentos de faturas bem-sucedidos, mas não são enviados quando você marca uma fatura como [paid_out_of_band](https://docs.stripe.com/api/invoices/pay.md#pay_invoice-paid_out_of_band). Os eventos `invoice.paid`, no entanto, são acionados tanto para pagamentos bem-sucedidos quanto para pagamentos fora da banda. Como o `invoice.paid` abrange os dois cenários, normalmente recomendamos ouvir o `invoice.paid` em vez `invoice.payment_succeeded`. Use a [ferramenta de webhook do Dashboard](https://dashboard.stripe.com/webhooks) ou siga o [início rápido do webhook](https://docs.stripe.com/webhooks/quickstart.md) para receber esses eventos e executar ações, como enviar um e-mail de confirmação do pedido ao cliente, registrar a venda em um banco de dados ou iniciar um fluxo de trabalho de envio. Além de gerenciar o evento `invoice.paid`, recomendamos gerenciar dois outros eventos ao coletar pagamentos com o Payment Element: | Evento | Descrição | Ação | | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [payment_intent.processing](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.processing) | Enviado quando um cliente inicia um pagamento, mas o pagamento ainda não foi concluído. Esse evento normalmente é enviado quando um débito bancário é iniciado. Ele é seguido por um evento `invoice.paid` ou `invoice.payment_failed` no futuro. | Envie ao cliente uma confirmação do pedido que indica que o pagamento está pendente. Para produtos digitais, pode ser necessário executar o pedido antes de aguardar a conclusão do pagamento. | | [invoice.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | Enviado quando um cliente tenta pagar uma fatura, mas o pagamento falha. | Se um pagamento passou de `processing` para `payment_failed`, ofereça ao cliente outra tentativa para pagar. | ## Optional: Personalizar uma fatura As [faturas podem ser personalizadas](https://docs.stripe.com/invoicing/customize.md) de várias maneiras. As opções de personalização da Stripe permitem adicionar sua própria marca e modificar suas faturas de acordo com os requisitos de cada jurisdição. ### Campos personalizados Adicione campos personalizados para aprimorar os documentos PDF da fatura e ajudar você a cumprir suas obrigações de práticas comerciais e declarações fiscais. Os campos personalizados permitem fornecer até quatro pares de valor de chave que são exibidos no cabeçalho da fatura. É possível configurar até quatro pares de valor de chave no [Editor de faturas](https://dashboard.stripe.com/invoices/create), com a [API Invoices](https://docs.stripe.com/api/invoices/create.md#create_invoice-custom_fields) ou com os [modelos de fatura](https://docs.stripe.com/invoicing/invoice-rendering-template.md). Veja a seguir alguns usos comuns dos campos personalizados: - Números de ordem de compra (OC) - Números do prestador de serviços - Conformidade fiscal Este é um exemplo de criação de uma fatura com um número de pedido e um imposto sobre valor agregado (IVA) como campos personalizados: ```curl curl https://api.stripe.com/v1/invoices \ -u "<>:" \ -d customer="{{CUSTOMER_ID}}" \ -d "custom_fields[0][name]"="PO number" \ -d "custom_fields[0][value]"=12345 \ -d "custom_fields[1][name]"=VAT \ -d "custom_fields[1][value]"=123ABC ``` #### Herança de campos personalizados Você pode definir campos de fatura personalizados no objeto [Customer](https://docs.stripe.com/api/customers/object.md#customer_object-invoice_settings-custom_fields). Qualquer campo personalizado definido para um cliente vale para todas as faturas provisórias geradas para esse cliente. Esses campos personalizados herdados podem ser alterados enquanto a fatura estiver em rascunho. Após a finalização da fatura, não é possível atualizar campos personalizados. Este é um exemplo da adição de campos personalizados por cliente para aplicação em todas as faturas provisórias futuras: ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ --data-urlencode email="jenny.rosen@example.com" \ -d payment_method=pm_card_visa \ -d "invoice_settings[default_payment_method]"=pm_card_visa \ -d "invoice_settings[custom_fields][0][name]"="PO number" \ -d "invoice_settings[custom_fields][0][value]"=12345 \ -d "invoice_settings[custom_fields][1][name]"=VAT \ -d "invoice_settings[custom_fields][1][value]"=123ABC ``` ## See also - [Pós-finalização](https://docs.stripe.com/invoicing/integration/workflow-transitions.md#post-finalized) - [Usar webhooks de entrada para obter atualizações em tempo real](https://docs.stripe.com/webhooks.md)