# Crie cobranças de destino

Crie cobranças na conta da sua plataforma, colete tarifas e transfira imediatamente os fundos restantes para suas contas conectadas.

Crie *cobranças de destino* quando os clientes fizerem transações com sua plataforma para produtos ou serviços fornecidos por suas contas conectadas e você transferir fundos imediatamente para suas contas conectadas. Com este tipo de cobrança:

- Você cria uma cobrança na conta da sua plataforma.
- Você determina se alguns ou todos os fundos são transferidos para a conta conectada.
- O custo das tarifas da Stripe e de reembolsos ou estornos é debitado da sua conta.

Esse tipo de cobrança funciona melhor para marketplaces como o Airbnb, um marketplace de aluguel de imóveis, ou para o Lyft, um aplicativo de transporte compartilhado.

Com [certas exceções](https://docs.stripe.com/connect/account-capabilities.md#transfers-cross-border), se sua plataforma e uma conta conectada não estiverem na mesma região, você deve especificar a conta conectada como o [comerciante da liquidação](https://docs.stripe.com/connect/destination-charges.md#settlement-merchant) usando o parâmetro `on_behalf_of` no [Payment Intent](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-on_behalf_of) ou `payment_intent_data.on_behalf_of` na [Checkout Session](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_intent_data-on_behalf_of).

Recomendamos usar cobranças de destino para contas conectadas que não têm acesso ao Stripe Dashboard completo.
![](https://b.stripecdn.com/docs-statics-srv/assets/android-overview.471eaf89a760f5b6a757fd96b6bb9b60.png)

Integre a IU de pagamento incorporada da Stripe no checkout do seu aplicativo Android com a classe [PaymentSheet](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html).

> #### Suporte à API Accounts v2
> 
> O Payment Sheet não oferece suporte a *Contas configuradas pelo cliente* (Account configurations represent role-based functionality that you can enable for accounts, such as merchant, customer, or recipient). Ele oferece suporte apenas a objetos `Customer`.

## Configurar a Stripe [Lado do servidor] [Lado do cliente]

Primeiro, você precisa de uma conta Stripe. [Cadastre-se agora](https://dashboard.stripe.com/register).

### Lado do servidor

Esta integração exige que os endpoints do seu servidor se comuniquem com a API da Stripe. Use as bibliotecas oficiais para acessar a API da Stripe pelo seu servidor:

#### 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'
```

### Lado do cliente

O [SDK da Stripe para Android](https://github.com/stripe/stripe-android) é de código aberto e [totalmente documentado](https://stripe.dev/stripe-android/).

Para instalar o SDK, adicione `stripe-android` ao bloco `dependencies` do arquivo [app/build.gradle](https://developer.android.com/studio/build/dependencies):

#### Kotlin

```kotlin
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Android SDK
  implementation("com.stripe:stripe-android:23.18.0")
  // Include the financial connections SDK to support US bank account as a payment method
  implementation("com.stripe:financial-connections:23.18.0")
}
```

> Veja mais informações sobre o último lançamento de SDK e as versões anteriores na página [Lançamentos](https://github.com/stripe/stripe-android/releases) no GitHub. Para receber notificações quando um novo lançamento for publicado, [assista aos lançamentos do repositório](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).

Configure o SDK com sua [chave publicável](https://dashboard.stripe.com/apikeys) da Stripe, de modo que seja possível fazer solicitações à API Stripe, como em sua subcategoria `Application`:

#### Kotlin

```kotlin
import com.stripe.android.PaymentConfiguration

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "<<YOUR_PUBLISHABLE_KEY>>"
        )
    }
}
```

> Use suas [chaves de teste](https://docs.stripe.com/keys.md#obtain-api-keys) enquanto testa e desenvolve, e suas chaves de [modo de produção](https://docs.stripe.com/keys.md#test-live-modes) quando publicar seu aplicativo.

## Adicionar um endpoint [Lado do servidor]

> #### Nota
> 
> Para exibir o PaymentSheet antes de criar um PaymentIntent, consulte [Colete os dados de pagamento antes de criar um Intent](https://docs.stripe.com/payments/accept-a-payment-deferred.md?type=payment).

Esta integração usa três objetos da API da Stripe:

1. [PaymentIntent](https://docs.stripe.com/api/payment_intents.md): A Stripe usa isso para representar sua intenção de coletar o pagamento de um cliente, acompanhando suas tentativas de cobrança e alterações no estado do pagamento durante todo o processo.

2. (Opcional) Uma [conta configurada pelo cliente](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-applied_configurations) ou um objeto [Cliente](https://docs.stripe.com/api/customers.md): para configurar uma forma de pagamento para pagamentos futuros, você deve associá-la a um cliente. Crie um objeto para representar seu cliente quando ele criar uma conta na sua empresa. Se o cliente fizer um pagamento como convidado, você poderá criar um objeto `Conta` ou `Cliente` antes do pagamento e associá-lo à sua própria representação interna da conta do cliente posteriormente.

3. (Opcional) [CustomerSession](https://docs.stripe.com/api/customer_sessions.md): os dados do objeto que representa seu cliente são confidenciais e não podem ser recuperados diretamente de um aplicativo. Uma `CustomerSession` concede ao SDK acesso temporário e restrito à `Conta` ou ao `Cliente` e oferece opções de configuração adicionais. Consulte a lista completa de [opções de configuração](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components).

> Se você nunca salvar cartões para os clientes e não permitir que clientes recorrentes reutilizem cartões salvos, poderá omitir os objetos `Conta` ou `Cliente` e o objeto `CustomerSession` da sua integração.

Por motivos de segurança, o aplicativo não pode criar esses objetos. Para isso, adicione um endpoint ao servidor para:

1. Recupera a `Conta` ou o `Cliente` ou cria um novo.
2. Cria uma [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) para a `Conta` ou o `Cliente`.
3. Cria um `PaymentIntent` com o [valor](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-amount), a [moeda](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-currency), e a [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) ou o [cliente](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer).
4. Retorna 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)) do `PaymentIntent`, o `client_secret` da `CustomerSession`, o ID da `Conta` ou do `Cliente` e sua [chave de publicação](https://dashboard.stripe.com/apikeys) do seu aplicativo.

Defina a mesma `Conta` ou `Cliente` no `PaymentIntent` que você definiu no `CustomerSession`.

As formas de pagamento mostradas aos clientes durante o processo de checkout também são incluídas no PaymentIntent. Você pode permitir que a Stripe obtenha as formas de pagamento das configurações do Dashboard ou listá-las manualmente. Independentemente da opção escolhida, saiba que a moeda passada no PaymentIntent filtra as formas de pagamento mostradas para o cliente. Por exemplo, se você passar EUR no `eur` e a OXXO estiver ativada no Dashboard, a OXXO não será exibida ao cliente porque a OXXO não aceita pagamentos em `eur`.

Se sua integração não exige uma opção baseada em código para oferecer formas de pagamento, a Stripe recomenda a opção automática. Isso ocorre porque a Stripe avalia a moeda, as restrições de forma de pagamento e outros parâmetros para determinar a lista de formas de pagamento aceitas. Priorizamos as formas de formas de pagamento que aumentam a conversão e que são mais relevantes para a moeda e a localização do cliente.

#### Gerenciar formas de pagamento no Dashboard

Você pode gerenciar as formas de pagamento no [Dashboard](https://dashboard.stripe.com/settings/payment_methods). A Stripe cria o `PaymentIntent` usando as formas de pagamento qualificadas que você configurou, com base em fatores como o valor da transação, a moeda e o fluxo de pagamento. Se você não quiser usar o Dashboard, ou se quiser especificar as formas de pagamento permitidas manualmente, pode usar o parâmetro `allowed_payment_method_types`.

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \

  -d "automatic_payment_methods[enabled]"=true \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

#### Listar manualmente as formas de pagamento

#### curl

```bash
# Create a Customer (use an existing Customer ID if this is a returning customer)
curl https://api.stripe.com/v1/customers \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"

# Create an CustomerSession for the Customer
curl https://api.stripe.com/v1/customer_sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "components[mobile_payment_element][enabled]"=true \
  -d "components[mobile_payment_element][features][payment_method_save]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_redisplay]"=enabled \
  -d "components[mobile_payment_element][features][payment_method_remove]"=enabled

# Create a PaymentIntent
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -X "POST" \
  -d "customer"="{{CUSTOMER_ID}}" \
  -d "amount"=1099 \
  -d "currency"="eur" \
  -d "allowed_payment_method_types[]"="bancontact" \
  -d "allowed_payment_method_types[]"="card" \
  -d "allowed_payment_method_types[]"="ideal" \
  -d "allowed_payment_method_types[]"="klarna" \
  -d "allowed_payment_method_types[]"="sepa_debit" \
  -d application_fee_amount="123" \
  -d "transfer_data[destination]"="{{CONNECTED_ACCOUNT_ID}}" \
```

> A forma de pagamento precisa aceitar a moeda passada no PaymentIntent. Além disso, sua empresa precisa estar estabelecida em um dos países aceitos pela forma de pagamento. Consulte a página [Opções de integração de formas de pagamento](https://docs.stripe.com/payments/payment-methods/integration-options.md) para obter mais detalhes sobre o que é aceito.

## Integrar a descrição da compra [Lado do cliente]

Antes de exibir o Element Pagamento para dispositivos móveis, a página de checkout deve:

- Mostrar os produtos sendo comprados e o valor total
- Colete todas as informações de envio necessárias usando o [Address Element](https://docs.stripe.com/elements/address-element.md?platform=android)
- Incluir um botão de checkout para apresentar a IU da Stripe

#### Jetpack Compose

[Inicializar](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-builder/index.html) uma instância de `PaymentSheet` dentro de `onCreate` da sua atividade de checkout, passando um método para gerenciar o resultado.

```kotlin
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
  val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult).build() }
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
  // implemented in the next steps
}
```

Em seguida, busque o segredo do cliente de Intenção Payment, o segredo do cliente da Sessão do cliente, a ID do cliente e a chave publicável do endpoint que você criou na etapa anterior. Defina a chave publicável usando`PaymentConfiguration` e armazene os outros para uso quando apresentar o PaymentSheet.

```kotlin
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import com.stripe.android.PaymentConfiguration
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
  val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()
  val context = LocalContext.current
  var customerConfig by remember { mutableStateOf<PaymentSheet.CustomerConfiguration?>(null) }
  varpaymentIntentClientSecret by remember { mutableStateOf<String?>(null) }

  LaunchedEffect(context) {
    // Make a request to your own server and retrieve payment configurations
    val networkResult = ...
    if (networkResult.isSuccess) {
paymentIntentClientSecret = networkResult.paymentIntent
        customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
          id = networkResult.customer,
          clientSecret = networkResult.customerSessionClientSecret
        )
        PaymentConfiguration.init(context, networkResult.publishableKey)
    }
  }
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
  // implemented in the next steps
}
```

Quando o cliente tocar no botão checkout, chame [presentWithPaymentIntent](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#1814490530%2FFunctions%2F2002900378) para apresentar a descrição da compra. Depois que o cliente conclui o pagamento, a descrição é descartada e o [PaymentSheetResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html) é chamado com um [PaymentSheetResult](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result/index.html).

```kotlin

import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.platform.LocalContext
import com.stripe.android.PaymentConfiguration
import com.stripe.android.paymentsheet.PaymentSheet
import com.stripe.android.paymentsheet.PaymentSheetResult

@Composable
fun App() {
  val paymentSheet = remember { PaymentSheet.Builder(::onPaymentSheetResult) }.build()
  val context = LocalContext.current
  var customerConfig by remember { mutableStateOf<PaymentSheet.CustomerConfiguration?>(null) }
  var paymentIntentClientSecret by remember { mutableStateOf<String?>(null) }

  LaunchedEffect(context) {
    // Make a request to your own server and retrieve payment configurations
    val networkResult = ...
    if (networkResult.isSuccess) {
        paymentIntentClientSecret = networkResult.paymentIntent
        customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
          id = networkResult.customer,
          clientSecret = networkResult.customerSessionClientSecret
        )
        PaymentConfiguration.init(context, networkResult.publishableKey)
    }
  }

  Button(
    onClick = {
      val currentConfig = customerConfig
      val currentClientSecret =paymentIntentClientSecret

      if (currentConfig != null && currentClientSecret != null) {
        presentPaymentSheet(paymentSheet, currentConfig, currentClientSecret)
      }
    }
  ) {
    Text("Checkout")
  }
}

private fun presentPaymentSheet(
  paymentSheet: PaymentSheet,
  customerConfig: PaymentSheet.CustomerConfiguration,
paymentIntentClientSecret: String
) {
  paymentSheet.presentWithPaymentIntent(
paymentIntentClientSecret,
    PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
      .customer(customerConfig)
      // Set `allowsDelayedPaymentMethods` to true if your business handles
      // delayed notification payment methods like US bank accounts.
      .allowsDelayedPaymentMethods(true)
      .build()
  )
}

private fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
  when(paymentSheetResult) {
    is PaymentSheetResult.Canceled -> {
      print("Canceled")
    }
    is PaymentSheetResult.Failed -> {
      print("Error: ${paymentSheetResult.error}")
    }
    is PaymentSheetResult.Completed -> {
      // Display for example, an order confirmation screen
      print("Completed")
    }
  }
}
```

#### Visualizações (Clássico)

[Inicialize](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#-394860221%2FConstructors%2F2002900378) uma instância de `PaymentSheet` dentro de `onCreate` da sua atividade de checkout, passando um método para gerenciar o resultado.

#### Kotlin

```kotlin
import com.stripe.android.paymentsheet.PaymentSheet

class CheckoutActivity : AppCompatActivity() {
  lateinit var paymentSheet: PaymentSheet

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult).build(this)
  }

  fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
    // implemented in the next steps
  }
}
```

Em seguida, busque o segredo do cliente de Intenção Payment, o segredo do cliente da Sessão do cliente, a ID do cliente e a chave publicável do endpoint que você criou na etapa anterior. Defina a chave publicável usando`PaymentConfiguration` e armazene os outros para uso quando apresentar o PaymentSheet.

#### Kotlin

```kotlin
import com.stripe.android.paymentsheet.PaymentSheet

class CheckoutActivity : AppCompatActivity() {
  lateinit var paymentSheet: PaymentSheet
  lateinit var customerConfig: PaymentSheet.CustomerConfiguration
  lateinit varpaymentIntentClientSecret: String

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    paymentSheet = PaymentSheet.Builder(::onPaymentSheetResult).build(this)
    lifecycleScope.launch {
      // Make a request to your own server and retrieve payment configurations
      val networkResult = MyBackend.getPaymentConfig()
      if (networkResult.isSuccess) {
paymentIntentClientSecret = networkResult.paymentIntent
        customerConfig = PaymentSheet.CustomerConfiguration.createWithCustomerSession(
          id = networkResult.customer,
          clientSecret = networkResult.customerSessionClientSecret
        )
        PaymentConfiguration.init(context, networkResult.publishableKey)
      }
    }
  }

  fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
    // implemented in the next steps
  }
}
```

Quando o cliente tocar no botão checkout, chame [presentWithPaymentIntent](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html#1814490530%2FFunctions%2F2002900378) para apresentar a descrição da compra. Depois que o cliente conclui o pagamento, a descrição é descartada e o [PaymentSheetResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html) é chamado com um [PaymentSheetResult](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result/index.html).

#### Kotlin

```kotlin
// ...
class CheckoutActivity : AppCompatActivity() {
  lateinit var paymentSheet: PaymentSheet
  lateinit var customerConfig: PaymentSheet.CustomerConfiguration
  lateinit var paymentIntentClientSecret: String
  // ...
  fun presentPaymentSheet() {
    paymentSheet.presentWithPaymentIntent(
paymentIntentClientSecret,
      PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
        .customer(customerConfig)
        // Set `allowsDelayedPaymentMethods` to true if your business handles
        // delayed notification payment methods like US bank accounts.
        .allowsDelayedPaymentMethods(true)
        .build()
    )
  }

  fun onPaymentSheetResult(paymentSheetResult: PaymentSheetResult) {
    when(paymentSheetResult) {
      is PaymentSheetResult.Canceled -> {
        print("Canceled")
      }
      is PaymentSheetResult.Failed -> {
        print("Error: ${paymentSheetResult.error}")
      }
      is PaymentSheetResult.Completed -> {
        // Display for example, an order confirmation screen
        print("Completed")
      }
    }
  }
}
```

Configurar `allowsDelayedPaymentMethods` como verdadeiro permite formas de pagamento de [notificação assíncrona](https://docs.stripe.com/payments/payment-methods.md#payment-notification) como contas bancárias dos EUA. Para essas formas de pagamento, o status final do pagamento não é conhecido quando o `PaymentSheet` é concluído, sendo efetivado ou não posteriormente. Se você aceitar esses tipos de formas de pagamento, informe o cliente que seu pedido está confirmado e somente processe o pedido (por exemplo, fazendo o envio do produto) quando o pagamento for bem-sucedido.

## Gerenciar eventos pós-pagamento [Lado do servidor]

Stripe envia um evento [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) quando o pagamento é concluído. Use a [ferramenta Dashboard webhook](https://dashboard.stripe.com/webhooks) ou siga o [guia de webhooks](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.

Escute esses eventos em vez de aguardar um retorno de chamada do cliente. No cliente, o consumidor pode fechar a janela do navegador ou sair do aplicativo antes da execução do retorno de chamada, o que permite que clientes mal-intencionados manipulem a resposta. Configurar sua integração para escutar eventos assíncronos é o que permite a você aceitar [diferentes tipos de formas de pagamento](https://stripe.com/payments/payment-methods-guide) com uma única integração.

Além de gerenciar o evento `payment_intent.succeeded`, recomendamos gerenciar esses outros eventos ao coletar pagamentos com o Element Pagamento:

| Evento | Descrição | Ação |
| --- | --- | --- |
| [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.succeeded) | Enviado quando um cliente conclui um pagamento com êxito. | Envie ao cliente uma confirmação de pedido e *processe* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) o pedido. |
| [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 precisa ser concluído. Esse evento costuma ser enviado quando um cliente inicia um débito bancário. Ele é seguido por um evento `payment_intent.succeeded` ou `payment_intent.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. |
| [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md?lang=php#event_types-payment_intent.payment_failed) | Enviado quando um cliente tenta fazer um pagamento, mas o pagamento falha. | Se um pagamento passa de `processing` para `payment_failed`, ofereça ao cliente outra tentativa para pagar. |

## Testar a integração

#### Cartões

| Número do cartão | Cenário | Como testar |
| --- | --- | --- |
| 4242424242424242 | O 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 do cartão de crédito com qualquer validade, CVC e código postal. |
| 4000002500003155 | O pagamento com cartão precisa de *autenticação* (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). | Preencha o formulário do cartão de crédito usando o número do cartão de crédito com qualquer validade, CVC e código postal. |
| 4000000000009995 | O 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 do cartão de crédito com qualquer validade, CVC e código postal. |
| 6205500000000000004 | O cartão UnionPay tem um comprimento variável de 13 a 19 dígitos. | Preencha o formulário do cartão de crédito usando o número do cartão de crédito com qualquer validade, CVC e código postal. |

#### Débito bancário autenticado

| Forma de pagamento | Cenário | Como testar |
| --- | --- | --- |
| Bancontact, iDEAL | Seu cliente não faz a autenticação na página de redirecionamento de uma forma de pagamento baseada em redirecionamento e notificação imediata. | Escolha qualquer forma de pagamento baseada em redirecionamento, preencha os dados obrigatórios e confirme o pagamento. Em seguida, clique em **Falhar pagamento de teste** na página de redirecionamento. |
| Pay by Bank | O cliente paga com uma forma de pagamento baseada em redirecionamento e [notificação posterior](https://docs.stripe.com/payments/payment-methods.md#payment-notification). | Escolha a forma de pagamento, preencha os dados obrigatórios e confirme o pagamento. Em seguida, clique em **Concluir o pagamento de teste** na página de redirecionamento. |
| Pay by Bank | Seu cliente não faz a autenticação na página de redirecionamento de uma forma de pagamento baseada em redirecionamento e notificação posterior. | Escolha a forma de pagamento, preencha os dados obrigatórios e confirme o pagamento. Em seguida, clique em **Falhar o pagamento de teste** na página de redirecionamento. |
| BLIK | Os pagamentos BLIK falham de várias formas: falhas imediatas (por exemplo, o código está vencido ou inválido), erros atrasados (o banco recusa) ou limites de tempo (o cliente não respondeu a tempo). | Use padrões de e-mail para [simular as diferentes falhas.](https://docs.stripe.com/payments/blik/accept-a-payment.md#simulate-failures) |

#### Débitos bancários

| Forma de pagamento | Cenário | Como testar |
| --- | --- | --- |
| Débito automático SEPA | O 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 processando e, três minutos depois, para bem-sucedido. |
| Débito automático SEPA | O status da intenção de pagamento do cliente muda de `processing` para `requires_payment_method`. | Preencha o formulário usando o número de conta `AT861904300235473202`. |

Consulte [Testes](https://docs.stripe.com/testing.md) para obter mais informações sobre como testar sua integração.

## Optional: Ativar Google Pay

### Configurar a integração

Para usar o Google Pay, habilite a API Google Pay adicionando o seguinte à `<application>` tag do seu **AndroidManifest.xml**:

```xml
<application>
  ...
  <meta-data
    android:name="com.google.android.gms.wallet.api.enabled"
    android:value="true" />
</application>
```

Veja mais detalhes na [Configuração da API Google Pay](https://developers.google.com/pay/api/android/guides/setup) do Google Pay para Android.

### Adicionar Google Pay

Para adicionar o Google Pay à sua integração, passe uma [PaymentSheet.GooglePayConfiguration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-google-pay-configuration/index.html) com seu ambiente do Google Pay (produção ou teste) e o [código do país da sua empresa](https://dashboard.stripe.com/settings/account) quando inicializar [PaymentSheet.Configuration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html).

#### Kotlin

```kotlin
val googlePayConfiguration = PaymentSheet.GooglePayConfiguration(
  environment = PaymentSheet.GooglePayConfiguration.Environment.Test,
  countryCode = "US",
  currencyCode = "USD" // Required for Setup Intents, optional for Payment Intents
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "My merchant name")
  .googlePay(googlePayConfiguration)
  .build()
```

### Testar Google Pay

O Google permite que você faça pagamentos de teste por meio de seu [Pacote de cartão de teste](https://developers.google.com/pay/api/android/guides/resources/test-card-suite). O Pacote de cartão de teste é compatível com os [cartões de teste](https://docs.stripe.com/testing.md) da Stripe.

Você precisa testar o Google Pay usando um dispositivo Android físico em vez de um dispositivo simulado, em um país onde o Google Pay é compatível. Faça login em uma conta do Google em seu dispositivo de teste com um cartão real salvo na Carteira do Google.

## Optional: Personalizar a descrição

Toda personalização é configurada usando o objeto [PaymentSheet.Configuration](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html).

### Aparência

Personalize cores, fontes e assim por diante para combinar com a aparência do seu aplicativo usando a [API appearance](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=android).

### Layout da forma de pagamento

Configure o layout das formas de pagamento na planilha usando [paymentMethodLayout](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/-builder/index.html#2123253356%2FFunctions%2F2002900378). Você pode exibi-los horizontalmente, verticalmente ou deixar a Stripe otimizar o layout automaticamente.
![](https://b.stripecdn.com/docs-statics-srv/assets/android-mpe-payment-method-layouts.3bcfe828ceaad1a94e0572a22d91733f.png)

#### Kotlin

```kotlin
PaymentSheet.Configuration.Builder("Example, Inc.")
  .paymentMethodLayout(PaymentSheet.PaymentMethodLayout.Automatic)
  .build()
```

### Coletar endereços de usuários

Colete endereços de entrega ou cobrança locais e internacionais de seus clientes usando o [Address Element](https://docs.stripe.com/elements/address-element.md?platform=android).

### Nome de exibição da empresa

Especifique o nome da empresa exibido para o cliente definindo [merchantDisplayName](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-configuration/index.html#-191101533%2FProperties%2F2002900378). Por padrão, esse é o nome do seu aplicativo.

#### Kotlin

```kotlin
PaymentSheet.Configuration.Builder(
  merchantDisplayName = "My app, Inc."
).build()
```

### Modo escuro

Por padrão, o `PaymentSheet` se adapta automaticamente às configurações de aparência do sistema do usuário (modo claro e escuro). É possível alterar isso configurando modo claro ou escuro no seu aplicativo:

#### Kotlin

```kotlin
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
```

### Dados de faturamento padrão

Para definir valores padrão para dados de faturamento coletados na descrição da compra, configure a propriedade `defaultBillingDetails`. A `PaymentSheet` preenche previamente seus campos com os valores que você informou.

#### Kotlin

```kotlin
val address = PaymentSheet.Address(country = "US")
val billingDetails = PaymentSheet.BillingDetails(
  address = address,
  email = "foo@bar.com"
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.")
  .defaultBillingDetails(billingDetails)
  .build()
```

### Configurar coleta de dados de cobrança

Use `BillingDetailsCollectionConfiguration` para especificar como você deseja coletar os dados de faturamento PaymentSheet.

Você pode coletar o nome, e-mail, número de telefone e endereço do cliente.

A coleta do endereço completo inclui o preenchimento automático que é fornecido pela Stripe para países compatíveis, sem necessidade de configuração adicional.

> Ao usar o preenchimento automático, você concorda em cumprir a [Política de uso aceitável da plataforma Google Maps](https://cloud.google.com/maps-platform/terms/aup). Se você violar essa política, a Stripe poderá desativar o preenchimento automático ou tomar outras medidas necessárias.

Se quiser anexar detalhes de cobrança padrão ao objeto PaymentMethod mesmo quando esses campos não forem coletados na IU, defina `billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` como `true`.

#### Kotlin

```kotlin
val billingDetails = PaymentSheet.BillingDetails(
  email = "foo@bar.com"
)
val billingDetailsCollectionConfiguration = BillingDetailsCollectionConfiguration(
  attachDefaultsToPaymentMethod = true,
  name = BillingDetailsCollectionConfiguration.CollectionMode.Always,
  email = BillingDetailsCollectionConfiguration.CollectionMode.Never,
  address = BillingDetailsCollectionConfiguration.AddressCollectionMode.Full,
)
val configuration = PaymentSheet.Configuration.Builder(merchantDisplayName = "Merchant, Inc.")
  .defaultBillingDetails(billingDetails)
  .billingDetailsCollectionConfiguration(billingDetailsCollectionConfiguration)
  .build()
```

> Consulte seu jurídico sobre as leis que se aplicam à coleta de dados. Só colete números de telefone se precisar deles para a transação.

## Optional: Conclua o pagamento em sua IU

Você pode exibir a Payment Sheet apenas para coletar dados da forma de pagamento e concluir o pagamento na IU do aplicativo. Isso é útil quando você tem um botão de compra personalizado ou precisa de mais etapas após a coleta dos dados do pagamento.
![](https://b.stripecdn.com/docs-statics-srv/assets/android-multi-step.84d8a0a44b1baa596bda491322b6d9fd.png)

> Um exemplo de integração está [disponível no nosso GitHub](https://github.com/stripe/stripe-android/blob/master/paymentsheet-example/src/main/java/com/stripe/android/paymentsheet/example/samples/ui/paymentsheet/custom_flow/CustomFlowActivity.kt).

1. Primeiro, inicialize [PaymentSheet.FlowController](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html) em vez de `PaymentSheet` usando um dos métodos do [Builder](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/-builder/index.html).

#### Android (Kotlin)

```kotlin
class CheckoutActivity : AppCompatActivity() {
  private lateinit var flowController: PaymentSheet.FlowController

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val flowController = PaymentSheet.FlowController.Builder(
      resultCallback = ::onPaymentSheetResult,
      paymentOptionResultCallback = ::onPaymentOption,
    ).build(this)
  }
}
```

1. Em seguida, chame `configureWithPaymentIntent` com as chaves do objeto Stripe recuperadas do backend e atualize a IU no callback usando [getPaymentOption()](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#-2091462043%2FFunctions%2F2002900378). Isso contém uma imagem e um rótulo que representam a forma de pagamento selecionada atualmente pelo cliente.

#### Android (Kotlin)

```kotlin
flowController.configureWithPaymentIntent(
  paymentIntentClientSecret = paymentIntentClientSecret,
  configuration = PaymentSheet.Configuration.Builder("Example, Inc.")
    .customer(PaymentSheet.CustomerConfiguration(
      id = customerId,
      ephemeralKeySecret = ephemeralKeySecret
    ))
    .build()
) { isReady, error ->
  if (isReady) {
    // Update your UI using `flowController.getPaymentOption()`
  } else {
    // handle FlowController configuration failure
  }
}
```

1. Em seguida, chame [presentPaymentOptions](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#449924733%2FFunctions%2F2002900378) para coletar os detalhes do pagamento. Quando o cliente termina, a descrição da compra é descartada e chama o [paymentOptionCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-option-callback/index.html) passado anteriormente em `create`. Implemente essa forma para atualizar a IU com o `paymentOption` retornado.

#### Android (Kotlin)

```kotlin
// ...
  flowController.presentPaymentOptions()
// ...
  private fun onPaymentOption(paymentOptionResult: PaymentOptionResult) {
    val paymentOption = paymentOptionResult.paymentOption
    if (paymentOption != null) {
      paymentMethodButton.text = paymentOption.label
      paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds(
        paymentOption.drawableResourceId,
        0,
        0,
        0
      )
    } else {
      paymentMethodButton.text = "Select"
      paymentMethodButton.setCompoundDrawablesRelativeWithIntrinsicBounds(
        null,
        null,
        null,
        null
      )
    }
  }
```

1. Por fim, chame [confirm](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html#-479056656%2FFunctions%2F2002900378) para finalizar o pagamento. Quando o cliente termina, a descrição da compra é descartada e chama o [paymentResultCallback](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet-result-callback/index.html#237248767%2FFunctions%2F2002900378) passado anteriormente em `create`.

#### Android (Kotlin)

```kotlin
  // ...
    flowController.confirmPayment()
  // ...

  private fun onPaymentSheetResult(
    paymentSheetResult: PaymentSheetResult
  ) {
    when (paymentSheetResult) {
      is PaymentSheetResult.Canceled -> {
        // Payment canceled
      }
      is PaymentSheetResult.Failed -> {
        // Payment Failed. See logcat for details or inspect paymentSheetResult.error
      }
      is PaymentSheetResult.Completed -> {
        // Payment Complete
      }
    }
  }
```

Configurar `allowsDelayedPaymentMethods` como verdadeiro permite formas de pagamento de [notificação assíncrona](https://docs.stripe.com/payments/payment-methods.md#payment-notification) como contas bancárias dos EUA. Para essas formas de pagamento, o status final do pagamento não é conhecido quando o `PaymentSheet` é concluído, sendo efetivado ou não posteriormente. Se você aceitar esses tipos de formas de pagamento, informe o cliente que seu pedido está confirmado e somente processe o pedido (por exemplo, fazendo o envio do produto) quando o pagamento for bem-sucedido.

## Tarifas cobradas

Quando um pagamento é processado, em vez de transferir o valor total da transação para uma conta conectada, sua plataforma pode decidir cobrar uma parte do valor da transação na forma de tarifas. Você pode definir os preços das tarifas de duas maneiras diferentes:

- Use a [ferramenta de preços da plataforma](https://docs.stripe.com/connect/platform-pricing-tools.md) para definir e testar as regras de preços das tarifas da plataforma. No momento, esse recurso no-code no Stripe Dashboard só está disponível para plataformas responsáveis pelo pagamento das tarifas da Stripe.

- Defina internamente as regras de preços, especificando as tarifas diretamente em um [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) usando o parâmetro [application_fee_amount](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-application_fee_amount) ou [transfer_data[amount]](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-transfer_data-amount). As tarifas definidas com esse método substituem a lógica de preços especificada na ferramenta de preços da plataforma.

#### application_fee_amount

Ao criar cobranças com `application_fee_amount`, o valor total da cobrança é imediatamente transferido da plataforma para a conta `transfer_data[destination]` depois que a cobrança é capturada. O valor `application_fee_amount` (limitado ao valor total da cobrança) é transferido de volta à plataforma em seguida.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=usd \
  -d "automatic_payment_methods[enabled]=true" \
  -d application_fee_amount=123 \
  -d "transfer_data[destination]={{CONNECTEDACCOUNT_ID}}"
```

Após a cobrança da tarifa de aplicação, um objeto [Application Fee](https://docs.stripe.com/api/application_fees/object.md) é criado. Você pode visualizar uma lista de tarifas de aplicação no [Dashboard](https://dashboard.stripe.com/connect/application_fees), com [tarifas da plataforma](https://docs.stripe.com/api/application_fees/list.md) ou no [Sigma](https://docs.stripe.com/data/how-sigma-works.md). Também é possível usar a propriedade `amount` no objeto de tarifa de aplicação para relatórios detalhados de tarifas.

Quando usar um `application_fee_amount`, lembre-se:

- O `application_fee_amount` é limitado ao valor total da transação.
- O `application_fee_amount` é sempre computado na mesma moeda da transação.
- A tarifa da plataforma é *liquidada* (When funds are available in your Stripe balance) na mesma moeda que a moeda de liquidação da conta conectada. Para destination charges internacionais, isso pode [ser diferente da moeda de liquidação da sua plataforma](https://docs.stripe.com/connect/currencies/fx-quotes-api.md#destination-charges-without-on-behalf-of).
- Sua plataforma paga a tarifa da Stripe após a transferência do `application_fee_amount` para sua conta.
- Nenhuma tarifa da Stripe adicional é aplicada ao valor.
- Sua plataforma pode usar relatórios integrados de tarifas da plataforma para reconciliar as [tarifas cobradas](https://dashboard.stripe.com/connect/application_fees).
- Em dashboards ou componentes hospedados na Stripe como o [componente de detalhes do pagamento](https://docs.stripe.com/connect/supported-embedded-components/payment-details.md), sua conta conectada pode visualizar o valor total e o valor da tarifa da plataforma.

### Fluxo de fundos com Destination Charges

Com o código acima, o valor total da cobrança (US$ 10,00) é adicionado ao saldo pendente da conta conectada. O valor `application_fee_amount` (US$ 1,23) é subtraído do valor da cobrança e transferido para sua plataforma. As tarifas da Stripe (US$ 0,59) são subtraídas do saldo da conta da plataforma. O valor da tarifa da plataforma, deduzido das tarifas da Stripe (US$ 1,23 - US$ 0,59 = US$ 0,64), permanece no saldo da conta da plataforma.
![Fluxo de fundos para Destination Charges](https://b.stripecdn.com/docs-statics-srv/assets/destination_charge_app_fee.c9ef81298155b38f986df02d0efa9167.png)

O `application_fee_amount` é disponibilizado no cronograma de transferências normal da conta da plataforma, assim como os fundos das cobranças normais da Stripe.

#### transfer_data[amount]

O `transfer_data[amount]` é um inteiro positivo que indica o valor da cobrança a ser transferido para `transfer_data[destination]`. Você subtrai as tarifas da plataforma do valor da cobrança e passa o resultado desse cálculo como `transfer_data[amount]`.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=usd \
  -d "automatic_payment_methods[enabled]=true" \
  -d "transfer_data[amount]=877" \
  -d "transfer_data[destination]={{CONNECTEDACCOUNT_ID}}"
```

Ao usar `transfer_data[amount]`, lembre-se:

- O valor é limitado ao valor total da transação.
- O valor é sempre computado na mesma moeda da transação.
- O valor é *liquidado* (When funds are available in your Stripe balance) [na mesma moeda que a moeda de liquidação da sua plataforma](https://docs.stripe.com/connect/currencies/fx-quotes-api.md#destination-charges-without-on-behalf-of).
- Nos dashboards hospedados em Stripe ou em componentes como o Stripe Dashboard ou Express Dashboard, sua conta conectada não consegue visualizar o valor total da cobrança. Ela só vê o valor transferido.
- Sua plataforma paga separadamente as tarifas da Stripe sobre a cobrança.
- Nenhuma tarifa da Stripe adicional é aplicada ao valor.
- Para [calcular tarifas](https://docs.stripe.com/data/query-all-fees-data.md#fees-paid-by-connected-accounts) após a criação de um pagamento, por exemplo, para fins de relatórios, [recupere o PaymentIntent](https://docs.stripe.com/api/payment_intents/retrieve.md) e subtraia `transfer_data[amount]` de `amount` no PaymentIntent

Considere usar o [valor da tarifa da plataforma](https://docs.stripe.com/connect/destination-charges.md#application-fee) para simplificar a declaração, criando tarifas de plataforma explícitas vinculadas à cobrança.

### Fluxo de fundos

Com o código acima, o `amount` da cobrança (US$ 10,00) é adicionado ao saldo da conta da plataforma. O `transfer_data[amount]` (US$ 8,77) é subtraído do saldo da conta da plataforma e adicionado ao saldo pendente da conta conectada. O `amount` da cobrança (US$ 10,00) menos o `transfer_data[amount]` (US$ 8,77) menos as tarifas da Stripe (sobre o `amount` da cobrança), totalizando US$ 0,64, permanece no saldo pendente da conta da plataforma.
![](https://b.stripecdn.com/docs-statics-srv/assets/destination_charge_amount.46cd59f6496607d68020b546aa1af85f.png)

O `transfer_data[amount]` é disponibilizado de acordo com o cronograma de transferências normal da conta conectada, da mesma forma que os fundos das cobranças normais da Stripe.

As plataformas podem acompanhar o valor retido das cobranças de `transfer_data[amount]` na coluna “Tarifa da plataforma de destino” na exportação do histórico do saldo.

## Especificar o comerciante da liquidação

O comerciante da liquidação depende das [funções](https://docs.stripe.com/connect/account-capabilities.md) da conta e da forma de criação da cobrança. O comerciante da liquidação determina quais dados são usados para fazer a cobrança. Isso inclui a descrição no extrato (da plataforma ou da conta conectada) exibida sobre essa cobrança no extrato bancário ou de cartão de crédito do cliente.

A especificação do comerciante da liquidação permite que você defina mais explicitamente para quem as cobranças são criadas. Por exemplo, algumas plataformas preferem ser o comerciante da liquidação porque o cliente final interage diretamente com a plataforma (como plataformas sob demanda). No entanto, algumas plataformas têm contas conectadas que interagem diretamente com os clientes finais (como lojas de uma plataforma de e-commerce). Nesses cenários, pode fazer mais sentido que a conta conectada seja o comerciante da liquidação.

Você pode definir o parâmetro `on_behalf_of` para o ID de uma conta conectada para tornar essa conta o comerciante de liquidação do pagamento. Quando usar `on_behalf_of`:

- As cobranças são *liquidadas* (When funds are available in your Stripe balance) no país da conta conectada e na *moeda de liquidação* (The settlement currency is the currency your bank account uses).
- É usada a estrutura de tarifas do país da conta conectada.
- A descrição no extrato da conta conectada é exibida no extrato do cartão de crédito do cliente.
- Se a conta conectada estiver em um país diferente do da plataforma, o endereço e o número de telefone da conta conectada serão exibidos no extrato do cartão de crédito do cliente.
- O número de dias que um [saldo pendente](https://docs.stripe.com/connect/account-balances.md) é retido antes de receber o repasse depende da configuração [delay_days](https://docs.stripe.com/api/accounts/create.md#create_account-settings-payouts-schedule-delay_days) na conta conectada.

> #### API Accounts v2
> 
> Você não pode usar a API Accounts v2 para gerenciar as configurações de repasse. Use a API Accounts v1.

Se `on_behalf_of` for omitido, a plataforma será a empresa registrada para o pagamento.

> O parâmetro `on_behalf_of` só é aceito para contas conectadas com uma função de pagamentos, como [card_payments](https://docs.stripe.com/connect/account-capabilities.md#card-payments). As contas sujeitas ao [contrato de serviços de destinatário](https://docs.stripe.com/connect/service-agreement-types.md#recipient) não podem solicitar `card_payments` nem outras funções de pagamento.

## Emitir reembolsos

Se você estiver usando a API Payment Intents, os reembolsos devem ser emitidos contra [a cobrança mais recente que foi criada](https://docs.stripe.com/payments/payment-intents/verifying-status.md#identifying-charges).

As cobranças criadas na conta da plataforma podem ser reembolsadas usando a chave secreta da conta da plataforma. No reembolso de uma cobrança que tem `transfer_data[destination]`, por padrão, a conta de destino mantém os fundos que foram transferidos para ela e o saldo negativo do reembolso é coberto pela conta da plataforma. Para recuperar os fundos da conta conectada a fim de cobrir o reembolso, defina o parâmetro `reverse_transfer` como `true` na criação do reembolso:

```curl
curl https://api.stripe.com/v1/refunds \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "charge={{CHARGE_ID}}" \
  -d reverse_transfer=true
```

Por padrão, o valor total da cobrança é reembolsado, mas você pode criar um reembolso parcial definindo `amount` como um inteiro positivo.

Se o valor total da cobrança é reembolsado, toda a transferência é anulada. Caso contrário, um valor proporcional da transferência é anulado.

### Reembolsar tarifas da plataforma

Quando você reembolsa uma cobrança com uma tarifa da plataforma, por padrão, a conta da plataforma mantém os fundos da tarifa da plataforma. Para devolver esses fundos para a conta conectada, defina o parâmetro [refund_application_fee](https://docs.stripe.com/api/refunds/create.md#create_refund-refund_application_fee) como `true` na criação do reembolso:

```curl
curl https://api.stripe.com/v1/refunds \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "charge={{CHARGE_ID}}" \
  -d reverse_transfer=true \
  -d refund_application_fee=true
```

Se você reembolsar a tarifa da plataforma de uma destination charge, também deverá anular a transferência. Se o reembolso resultar no reembolso total da cobrança, o reembolso também incluirá integralmente a tarifa da plataforma. Caso contrário, você reembolsa um valor proporcional da tarifa da plataforma.

Você também pode informar um valor **false** para `refund_application_fee` e reembolsar a tarifa da plataforma separadamente [usando a API](https://docs.stripe.com/api.md#create_fee_refund).

### Reembolsos com falha

Quando um reembolso falha ou você [o cancela](https://docs.stripe.com/refunds.md#cancel-refund), o valor do reembolso não finalizado retorna ao seu saldo da conta da plataforma na Stripe. Crie uma [transferência](https://docs.stripe.com/connect/separate-charges-and-transfers.md#create-transfer) se precisar movimentar os fundos para a conta conectada.

## Gerenciar contestações

Para cobranças de destino, com ou sem `on_behalf_of`, a Stripe debita os valores da contestação e as tarifas da conta da sua plataforma.

Recomendamos configurar [um webhook](https://docs.stripe.com/webhooks.md) para escutar [eventos criados por contestação](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.created). Se isso acontecer, tente recuperar fundos da conta conectada anulando a transferência pelo [Dashboard](https://dashboard.stripe.com/test/transfers) ou [criando uma anulação de transferência](https://docs.stripe.com/api/transfer_reversals/create.md).

Se o saldo da conta conectada for negativo, a Stripe tenta [debitar sua conta externa](https://docs.stripe.com/connect/account-balances.md#automatically-debit-connected-accounts) se `debit_negative_balances` estiver definido como `true`.

Se você desafiar a contestação e vencer, poderá transferir os fundos que devolveu anteriormente para a conta conectada. Se sua plataforma tiver saldo insuficiente, a transferência falhará. Evite erros de saldo insuficiente [adicionando fundos ao seu saldo da Stripe](https://docs.stripe.com/get-started/account/add-funds.md).

> A retransferência de uma anulação anterior está sujeita a [restrições de transferências internacionais](https://docs.stripe.com/connect/account-capabilities.md#transfers-cross-border), o que significa que você pode não como pagar sua conta conectada. Aguarde para recuperar transferências de pagamento internacionais contestadas para cobranças de destino com `on_behalf_of` até depois que a contestação for perdida.

## Falhas de pagamento assíncronas

Para cobranças de destino que usam formas de pagamento assíncronas (como débito ACH ou débito SEPA), há um atraso entre o início do pagamento e a confirmação dos fundos. Durante esse período, tanto a cobrança quanto a transferência do saldo pendente da conta conectada ficam em estado pendente.

Se o pagamento assíncrono falhar, a Stripe reverte automaticamente a transferência. Nenhum fundo é transferido permanentemente para a conta conectada.

## Transferências ignoradas devido ao status da conta

Para pagamentos que usam formas de pagamento assíncronas (como ACH ou débito SEPA), há um atraso entre o momento em que o pagamento é autorizado e o momento em que os fundos são disponibilizados. Nesse período, se a conta de destino perder a [funcionalidade de transferência](https://docs.stripe.com/connect/account-capabilities.md#supported-capabilities) necessária ou for fechada, a Stripe não poderá concluir a transferência conforme solicitado originalmente.

Quando a Stripe tenta criar uma transferência, mas não consegue em razão da perda de funcionalidade ou da exclusão de conta, a transferência é ignorada e os fundos permanecem no saldo da sua plataforma.

Para detectar transferências ignoradas, ouça o evento webhook `charge.updated`. Se o valor de [transfer_data](https://docs.stripe.com/api/charges/object.md#charge_object-transfer_data) no objeto Cobrança for `null`, será uma indicação de uma transferência ignorada.

Quando você detectar uma transferência ignorada, poderá criar uma transferência após resolver o problema.

## Componentes integrados do Connect

As Destination Charges são suportadas por [componentes integrados do Connect](https://docs.stripe.com/connect/get-started-connect-embedded-components.md). Ao usar o [componente de pagamentos integrado](https://docs.stripe.com/connect/supported-embedded-components/payments.md), você pode habilitar suas contas conectadas a visualizar informações de pagamento a partir do seu site. Para Destination Charges com `on_behalf_of`, você pode usar o recurso [destination_on_behalf_of_charge_management](https://docs.stripe.com/api/account_sessions/create.md#create_account_session-components-payments-features-destination_on_behalf_of_charge_management) para permitir que suas contas conectadas visualizem mais detalhes, gerenciem reembolsos, contestações e permitam a captura de pagamentos.

Note: The following is a preview/demo component that behaves differently than live mode usage with real connected accounts. The actual component has more functionality than what might appear in this demo component. For example, for connected accounts without Stripe dashboard access (custom accounts), no user authentication is required in production.

Os seguintes componentes exibem informações sobre Destination Charges:

- [Componente de pagamentos](https://docs.stripe.com/connect/supported-embedded-components/payments.md): Exibe todos os pagamentos e contestações de uma conta.

- [Detalhes dos pagamentos](https://docs.stripe.com/connect/supported-embedded-components/payment-details.md): Exibe todos os pagamentos e contestações de uma conta.

- [Componente de lista de contestações](https://docs.stripe.com/connect/supported-embedded-components/disputes-list.md): Exibe todas as contestações de uma conta.

- [Disputas para um componente de pagamento](https://docs.stripe.com/connect/supported-embedded-components/disputes-for-a-payment.md): Exibe as contestações para um único pagamento especificado. Você pode usá-lo para incluir a função de gerenciamento de contestação em uma página com sua IU de pagamentos.

## See also

- [Trabalhar com várias moedas](https://docs.stripe.com/connect/currencies.md)
- [Descrições no extrato com o Connect](https://docs.stripe.com/connect/statement-descriptors.md)