# Apple Pay

Permita pagamentos seguros com Apple Pay no iPhone, iPad ou Apple Watch.

Consulte a [documentação de compatibilidade](https://support.apple.com/en-us/HT208531) da Apple para saber quais dispositivos aceitam Apple Pay.

O Apple Pay é compatível com a maioria dos produtos e recursos da Stripe. Os usuários da Stripe podem aceitar [Apple Pay](https://stripe.com/apple-pay) em aplicativos iOS em iOS 9 e mais recentes, e na web com Safari iniciando por iOS 10 ou macOS Sierra. Não há tarifas adicionais para processar pagamentos com Apple Pay e os [preços](https://stripe.com/pricing/local-payment-methods#apple-pay) são os mesmos de outras transações com cartão.

O Apple Pay está disponível para titulares de cartão em bancos participantes de países aceitos. Para obter mais informações, consulte a documentação da Apple sobre [bancos participantes](https://support.apple.com/en-us/ht204916).

#### Propriedades da forma de pagamento

- **Localização dos clientes**

  Em todo o mundo, exceto Índia

- **Moeda de apresentação**

  Ver [moedas de apresentação aceitas](https://docs.stripe.com/currencies.md#presentment-currencies)

- **Confirmação do pagamento**

  Iniciada pelo cliente

- **Família da forma de pagamento**

  Carteira

- **Pagamentos recorrentes**

  [Sim](https://docs.stripe.com/apple-pay.md#recurring-payments)

- **Frequência de repasses**

  Cronograma de repasses padrão

- **Aceita Connect**

  Sim

- **Aceita contestações**

  [Sim](https://docs.stripe.com/apple-pay/disputes-refunds.md#disputed-payments)

- **Aceita captura manual**

  Sim

- **Reembolsos totais/parciais**

  [Sim/Sim](https://docs.stripe.com/apple-pay/disputes-refunds.md#refunds)

#### Locais da empresa

Contas Stripe em todo o mundo, exceto na Índia, podem aceitar pagamentos Apple Pay com liquidação em moeda local.

#### Suporte de produto

- Connect
- Checkout1

- Payment Links
- Elements
- Subscriptions
- Invoicing

1When Checkout’s [ui_mode](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-ui_mode) is `embedded_page`, it only supports version 17 or later of Safari and iOS.

## Fluxo de pagamentos

Veja abaixo uma demonstração do fluxo de pagamento do Apple Pay na sua página de checkout:
![Animação do fluxo de pagamento do Apple Pay mostrando a página de checkout da Stripe, o botão Apple Pay e a caixa de diálogo de confirmação durante o teste.](https://b.stripecdn.com/docs-statics-srv/assets/apple-pay.3447ce2deeaab40d6d231eed4dc34644.gif)

## Elegibilidade para compras no aplicativo com Apple Pay

Este guia explica como configurar seu aplicativo para aceitar o Apple Pay diretamente para bens físicos, serviços e outros itens qualificados. A Stripe processa esses pagamentos, e você paga apenas as [tarifas de processamento da Stripe](https://stripe.com/pricing).

Para produtos digitais, conteúdos e assinaturas vendidos nos Estados Unidos ou no Espaço Econômico Europeu (EEE), seu aplicativo pode aceitar o Apple Pay redirecionando para uma página de pagamentos externa. Você pode usar as seguintes interfaces de pagamento:

- [Stripe Checkout](https://docs.stripe.com/mobile/digital-goods/checkout.md)
- [Web Elements](https://docs.stripe.com/mobile/digital-goods/custom-checkout.md)
- [Links de pagamento](https://docs.stripe.com/mobile/digital-goods/payment-links.md) (melhor para um número limitado de produtos e preços)

Em outras regiões, seu aplicativo não pode aceitar o Apple Pay para produtos digitais, conteúdo ou assinaturas.

## Aceitar Apple Pay

A Stripe oferece vários métodos para adicionar o Apple Pay como forma de pagamento. Para obter detalhes da integração, selecione o método de sua preferência:

# iOS nativo

> This is a iOS nativo for when platform is ios. View the full page at https://docs.stripe.com/apple-pay?platform=ios.

> Se você estiver usando a [IU predefinida](https://docs.stripe.com/payments/mobile.md) da Stripe, siga as etapas descritas [este guia](https://docs.stripe.com/payments/mobile/accept-payment.md?platform=ios&type=payment#apple-pay).

Com o [SDK da Stripe para iOS](https://github.com/stripe/stripe-ios), você pode aceitar Apple Pay e pagamentos com cartão de crédito tradicionais. Antes de iniciar, você precisa se inscrever no [Apple Developer Program](https://developer.apple.com/programs/). Em seguida, siga estas etapas:

1. [Configurar a Stripe](https://docs.stripe.com/apple-pay.md#setup)
1. [Solicitar um ID de comerciante da Apple](https://docs.stripe.com/apple-pay.md#merchantid)
1. [Criar um certificado Apple Pay](https://docs.stripe.com/apple-pay.md#csr)
1. [Integrar com Xcode](https://docs.stripe.com/apple-pay.md#xcode-pay)
1. [Verificar se Apple Pay é aceito](https://docs.stripe.com/apple-pay.md#check-if-apple-pay-supported)
1. [Criar a solicitação de pagamento](https://docs.stripe.com/apple-pay.md#create-payment-request)
1. [Apresentar a descrição da compra](https://docs.stripe.com/apple-pay.md#present-payment-sheet)
1. [Enviar o pagamento à Stripe](https://docs.stripe.com/apple-pay.md#handle-payment)

## Configurar a Stripe [Lado do servidor] [Do 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 iOS](https://github.com/stripe/stripe-ios) é de código aberto, [totalmente documentado](https://stripe.dev/stripe-ios/index.html) e compatível com aplicativos que aceitam iOS 13 ou versões mais recentes.

#### Gerenciador de pacotes Swift

Para instalar o SDK, siga estas etapas:

1. No Xcode, selecione **Arquivo** > **Adicionar dependências de pacote…** e insira `https://github.com/stripe/stripe-ios-spm` como URL do repositório.
1. Selecione o número da última versão da nossa [página de lançamentos](https://github.com/stripe/stripe-ios/releases).
1. Adicione o produto **StripeApplePay** ao [alvo do seu aplicativo](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app).

#### CocoaPods

1. Se ainda não o fez, instale a versão mais recente do [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Se não tiver um [Podfile](https://guides.cocoapods.org/syntax/podfile.html), execute o seguinte comando para criar um:
   ```bash
   pod init
   ```
1. Adicione esta linha ao seu `Podfile`:
   ```podfile
   pod 'StripeApplePay'
   ```
1. Execute o seguinte comando:
   ```bash
   pod install
   ```
1. Não se esqueça de usar o arquivo `.xcworkspace` para abrir seu projeto em Xcode, em vez do arquivo `.xcodeproj`, daqui em diante.
1. No futuro, para atualizar para a versão mais recente do SDK, execute:
   ```bash
   pod update StripeApplePay
   ```

#### Carthage

1. Se ainda não o fez, instale a versão mais recente do [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Adicione esta linha ao seu `Cartfile`:
   ```cartfile
   github "stripe/stripe-ios"
   ```
1. Siga as [instruções de instalação do Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Certifique-se de integrar todas as estruturas necessárias listadas [here](https://github.com/stripe/stripe-ios/tree/master/StripeApplePay/README.md#manual-linking).
1. No futuro, para atualizar para a versão mais recente do SDK, execute o seguinte comando:
   ```bash
   carthage update stripe-ios --platform ios
   ```

#### Estrutura manual

1. Vá até a nossa [página de lançamentos do GitHub](https://github.com/stripe/stripe-ios/releases/latest) e baixe e descompacte o **Stripe.xcframework.zip**.
1. Arraste **StripeApplePay.xcframework** até a seção **Embedded Binaries** das configurações **General** no seu projeto Xcode. Certifique-se de selecionar **Copy items if needed**.
1. Repita a etapa 2 para todas as estruturas necessárias listadas [here](https://github.com/stripe/stripe-ios/tree/master/StripeApplePay/README.md#manual-linking).
1. No futuro, para atualizar para a versão mais recente do nosso SDK, repita as etapas 1 a 3.

> Para obter mais informações sobre a versão mais recente e as versões anteriores do SDK, consulte a página [Lançamentos](https://github.com/stripe/stripe-ios/releases) no GitHub. Para receber notificações quando um novo lançamento for publicado, [assista aos lançamentos](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) do repositório.

Configure o SDK com sua [chave publicável da Stripe](https://dashboard.stripe.com/test/apikeys) na inicialização do aplicativo. Isso permite que seu aplicativo faça solicitações à API da Stripe .

#### Swift

```swift
import UIKitimportStripeApplePay

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<<YOUR_PUBLISHABLE_KEY>>"
        // do any other necessary launch configuration
        return true
    }
}
```

> 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.

## Solicitar um ID de comerciante da Apple

Obtenha um ID de comerciante da Apple [solicitando um novo identificador](https://developer.apple.com/account/resources/identifiers/add/merchant) no site de desenvolvedores da Apple.

Preencha o formulário com descrição e identificador. A descrição é para seu controle e pode ser modificada no futuro. A Stripe recomenda que você use o nome do aplicativo como identificador (por exemplo, `merchant.com.{{YOUR_APP_NAME}}`).

## Criar um certificado do Apple Pay

Crie um certificado para criptografia de dados de pagamento pelo aplicativo.

Vá até [Configurações de certificado do iOS](https://dashboard.stripe.com/settings/ios_certificates) no Dashboard, clique em **Adicionar novo aplicativo** e siga o guia.

Baixe um arquivo de solicitação de assinatura de certificado (CSR) para obter um certificado seguro da Apple que permite usar o Apple Pay.

Um arquivo CSR deve ser usado para emitir exatamente um certificado. Se você trocar seu ID de comerciante da Apple, acesse as [Configurações de certificado do iOS](https://dashboard.stripe.com/settings/ios_certificates) no Dashboard para obter um novo CSR e certificado.

## Integrar com Xcode

Adicione as funções do Apple Pay ao aplicativo. No Xcode, abra as configurações do projeto, clique na guia **Signing & Capabilities** e adicione o recurso **Apple Pay**. Talvez seja necessário fazer login na sua conta de desenvolvedor. Selecione o ID de comerciante criado anteriormente e o aplicativo já pode aceitar Apple Pay.
![](https://b.stripecdn.com/docs-statics-srv/assets/xcode.a701d4c1922d19985e9c614a6f105bf1.png)

Habilitar o recurso Apple Pay no Xcode

## Verificar se o Apple Pay é aceito

Antes de mostrar o Apple Pay como forma de pagamento no aplicativo, verifique se o dispositivo do usuário aceita Apple Pay e se o usuário adicionou um cartão à sua carteira:

#### Swift

```swift
import StripeApplePay
import PassKit

class CheckoutViewController: UIViewController, ApplePayContextDelegate {
    let applePayButton: PKPaymentButton = PKPaymentButton(paymentButtonType: .plain, paymentButtonStyle: .black)

    override func viewDidLoad() {
        super.viewDidLoad()
        // Only offer Apple Pay if the customer can pay with it
        applePayButton.isHidden = !StripeAPI.deviceSupportsApplePay()
        applePayButton.addTarget(self, action: #selector(handleApplePayButtonTapped), for: .touchUpInside)
    }

    // ...continued in next step
}
```

## Criar a solicitação de pagamento

Quando o usuário toca no botão **Apple Pay**, chame [StripeAPI paymentRequestWithMerchantIdentifier:country:currency:](https://stripe.dev/stripe-ios/stripe-payments/Classes/StripeAPI.html#/c:@M@StripeCore@objc\(cs\)StripeAPI\(cm\)paymentRequestWithMerchantIdentifier:country:currency:) para criar um [PKPaymentRequest](https://developer.apple.com/documentation/passkit/pkpaymentrequest).

Em seguida, configure `PKPaymentRequest` para exibir o nome da empresa e o total. Também é possível coletar informações, como dados de cobrança ou entrega.

Consulte a [documentação da Apple](https://developer.apple.com/design/human-interface-guidelines/apple-pay/overview/checkout-and-payment/#customize-the-payment-sheet) para obter orientações completas sobre como personalizar a solicitação de pagamento.

#### Swift

```swift
func handleApplePayButtonTapped() {
    let merchantIdentifier = "merchant.com.your_app_name"
    let paymentRequest = StripeAPI.paymentRequest(withMerchantIdentifier: merchantIdentifier, country: "US", currency: "USD")

    // Configure the line items on the payment request
    paymentRequest.paymentSummaryItems = [
        // The final line should represent your company;
        // it'll be prepended with the word "Pay" (that is, "Pay iHats, Inc $50")
        PKPaymentSummaryItem(label: "iHats, Inc", amount: 50.00),
    ]
    // ...continued in next step
}
```

## Apresentar a descrição da compra

Crie uma instância de [STPApplePayContext](https://stripe.dev/stripe-ios/stripe-applepay/Classes/STPApplePayContext.html) com o `PKPaymentRequest` e use-a para apresentar a descrição de compra do Apple Pay:

#### Swift

```swift
func handleApplePayButtonTapped() {
    // ...continued from previous step

    // Initialize an STPApplePayContext instance
    if let applePayContext = STPApplePayContext(paymentRequest: paymentRequest, delegate: self) {
        // Present Apple Pay payment sheet
        applePayContext.presentApplePay(on: self)
    } else {
        // There is a problem with your Apple Pay configuration
    }
}
```

A Apple exige que os gestos do usuário acionem o modal Apple Pay (por exemplo, clicando em um botão ou interagindo com o formulário). Verifique se o código está de acordo com os itens a seguir:

- Invocar a descrição da compra diretamente com um evento de ativação do usuário.
- Adicionar o código da descrição da compra na parte superior ou próxima ao seu gerenciador de eventos de gestos de usuário, antes de qualquer código assíncrono ou de longa execução.
- Definir um limite de tempo razoável para chamar `confirmPayment` após o gesto do usuário.

## Enviar o pagamento para a Stripe

### Lado do servidor

Crie um endpoint que crie um PaymentIntent com um [valor](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) e uma [moeda](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency). Sempre decida quanto cobrar do lado do servidor, um ambiente seguro, em vez do lado do cliente. Isso evita que clientes mal-intencionados possam escolher os preços.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd"
```

### Do lado do cliente

#### API Payment Intents

Implemente `applePayContext(_:didCreatePaymentMethod:paymentInformation:)` para retornar o segredo do cliente do PaymentIntent obtido no endpoint acima ou gerar um erro caso a solicitação falhe.

Depois que você retornar o segredo do cliente, o `STPApplePayContext` conclui o pagamento, fecha a janela do Apple Pay e chama `applePayContext(_:didCompleteWithStatus:error:)` com o status do pagamento. Implemente esse método para exibir o recibo ao cliente.

#### Swift

```swift
extension CheckoutViewController {
    func applePayContext(_ context: STPApplePayContext, didCreatePaymentMethod paymentMethod: StripeAPI.PaymentMethod, paymentInformation: PKPayment) async throws -> String {
        let clientSecret = try await ... // Retrieve the PaymentIntent client secret from your backend (see Server-side step above)
        // Return the client secret or throw an error
        return clientSecret
    }

    func applePayContext(_ context: STPApplePayContext, didCompleteWith status: STPApplePayContext.PaymentStatus, error: Error?) {
          switch status {
        case .success:
            // Payment succeeded, show a receipt view
            break
        case .error:
            // Payment failed, show the error
            break
        case .userCancellation:
            // User canceled the payment
            break
        @unknown default:
            fatalError()
        }
    }
}
```

Por fim, [trate os eventos pós-pagamento](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=mobile&platform=ios#ios-post-payment) para realizar ações como enviar um e-mail de confirmação de pedido ao cliente, registrar a venda em um banco de dados ou iniciar um fluxo de trabalho de entrega.

#### API Payment Intents (confirmação do lado do servidor)

Implemente `applePayContext(_:didCreatePaymentMethod:paymentInformation:)` para enviar `paymentMethod.id` ao seu servidor e criar e confirmar o PaymentIntent. Retorne o segredo do cliente do PaymentIntent recebido do seu servidor ou gere um erro caso a solicitação falhe.

Depois que você retornar o segredo do cliente, o `STPApplePayContext` conclui o pagamento, fecha a janela do Apple Pay e chama `applePayContext(_:didCompleteWithStatus:error:)` com o status do pagamento. Implemente esse método para exibir o recibo ao cliente.

#### Swift

```swift
extension CheckoutViewController {
    func applePayContext(_ context: STPApplePayContext, didCreatePaymentMethod paymentMethod: StripeAPI.PaymentMethod, paymentInformation: PKPayment) async throws -> String {
        let clientSecret = try await ... // Call your backend to create and confirm a PaymentIntent and get its client secret
        // Return the client secret or throw an error
        return clientSecret
    }

    func applePayContext(_ context: STPApplePayContext, didCompleteWith status: STPApplePayContext.PaymentStatus, error: Error?) {
          switch status {
        case .success:
            // Payment succeeded, show a receipt view
            break
        case .error:
            // Payment failed, show the error
            break
        case .userCancellation:
            // User canceled the payment
            break
        @unknown default:
            fatalError()
        }
    }
}
```

### Solução de problemas

Quando ocorrem erros da API Stripe durante a criação de tokens, é provável que o problema esteja no certificado do Apple Pay. Gere um novo certificado e carregue-o na Stripe, como descrito nesta página. Use um CSR obtido do Dashboard (não use certificados gerados por você mesmo). Muitas vezes, o Xcode armazena incorretamente certificados antigos no cache. Por isso, além de gerar um novo certificado, a Stripe recomenda que você também crie outro ID de comerciante da Apple.

O erro:

> Você não adicionou a conta de comerciante da Apple à Stripe

pode indicar que o aplicativo está enviando dados criptografados com um CSR/certificado anterior (que não é da Stripe). No seu ID de comerciante da Apple, revogue todos os certificados gerados por CSRs que não sejam da Stripe . Se o erro persistir, exclua o ID de comerciante da conta Apple e crie o ID novamente. Em seguida, crie um certificado baseado no mesmo CSR (fornecido pela Stripe) usando anteriormente. Não é necessário carregar esse novo certificado para a Stripe. Para concluir, desative e ative as credenciais do Apple Pay no aplicativo para atualizá-las.

## Clipes de Apps

O módulo `StripeApplePay` é um SDK leve da Stripe, otimizado para uso em um [Clipe de App](https://developer.apple.com/app-clips/). Siga [as instruções acima](https://docs.stripe.com/apple-pay.md?platform=ios#accept) para adicionar o módulo `StripeApplePay` ao destino do Clipe de App.

> O módulo `StripeApplePay` é aceito apenas pelo Swift. Usuários de Objective-C precisam importar `STPApplePayContext` do módulo `Stripe`.

### Migração do STPApplePayContext

Se você é um usuário atual do `STPApplePayContext` e quer mudar para o SDK leve do Apple Pay, siga estas instruções:

1. Nas dependências do destino do Clipe de App, substitua o módulo `Stripe` pelo módulo `StripeApplePay`.
1. Na programação, substitua `import Stripe` por `import StripeApplePay`.
1. Substitua o uso de `STPApplePayContextDelegate` pelo novo protocolo `ApplePayContextDelegate`.
1. Altere a sua implementação de `applePayContext(_:didCreatePaymentMethod:)` para aceitar um `StripeAPI.PaymentMethod`.
1. Altere sua implementação de `applePayContext(_:didCompleteWith:error:)` para aceitar um `STPApplePayContext.PaymentStatus`.

### Before

```swift


    func applePayContext(_ context: STPApplePayContext,
      paymentInformation: PKPayment,
        // ...
    }

    func applePayContext(_ context: STPApplePayContext,
      error: Error?) {
        // ...
    }
}
```

### After

```swift
import StripeApplePay
class CheckoutViewController: UIViewController, ApplePayContextDelegate {
    func applePayContext(_ context: STPApplePayContext,didCreatePaymentMethod paymentMethod: StripeAPI.PaymentMethod,
      paymentInformation: PKPayment
        // ...} async throws -> String {

    func applePayContext(_ context: STPApplePayContext,didCompleteWith status: STPApplePayContext.PaymentStatus,
      error: Error?) {
        // ...
    }
}
```

## Pagamentos recorrentes

No iOS 16 ou posterior, você pode adotar [tokens de comerciante](https://developer.apple.com/apple-pay/merchant-tokens/) definindo as propriedades `recurringPaymentRequest` ou `automaticReloadPaymentRequest` em `PKPaymentRequest`.

Os pagamentos recorrentes podem usar formas de pagamento salvas somente para [transações fora da sessão](https://docs.stripe.com/apple-pay/apple-pay-recurring.md#set-up-off-session-payments).

#### Swift

```swift
extension CheckoutViewController {
  func handleApplePayButtonTapped() {
    let request = StripeAPI.paymentRequest(withMerchantIdentifier: merchantIdentifier, country: "US", currency: "USD")

    let billing = PKRecurringPaymentSummaryItem(label: "My Subscription", amount: NSDecimalNumber(string: "59.99"))
    billing.startDate = Date()
    billing.endDate = Date().addingTimeInterval(60 * 60 * 24 * 365)
    billing.intervalUnit = .month

    request.recurringPaymentRequest = PKRecurringPaymentRequest(paymentDescription: "Recurring",
                                                                regularBilling: billing,
                                                                managementURL: URL(string: "https://my-backend.example.com/customer-portal")!)
    request.recurringPaymentRequest?.billingAgreement = "You'll be billed $59.99 every month for the next 12 months. To cancel at any time, go to Account and click 'Cancel Membership.'"
    request.paymentSummaryItems = [billing]
  }
}
```

Para saber mais sobre como usar pagamentos recorrentes com o Apple Pay, consulte a [documentação do PassKit da Apple](https://developer.apple.com/documentation/passkit/pkpaymentrequest).

## Rastreamento de pedidos

Para adotar o [rastreamento de pedidos](https://developer.apple.com/design/human-interface-guidelines/technologies/wallet/designing-order-tracking) no iOS 16 ou posterior, implemente a função[applePayContext(context:willCompleteWithResult:handler:)](https://github.com/stripe/stripe-ios/blob/22.8.0/StripeApplePay/StripeApplePay/Source/ApplePayContext/STPApplePayContext.swift#L38) em seu `ApplePayContextDelegate`. A Stripe chama sua implementação após a conclusão do pagamento, mas antes que o iOS ignore a descrição de compra do Apple Pay.

Em sua implementação:

1. Obtenha em seu servidor os detalhes do pedido concluído.
1. Adicione esses detalhes ao [PKPaymentAuthorizationResult](https://developer.apple.com/documentation/passkit/pkpaymentauthorizationresult).
1. Chame o gerenciador de conclusão informado na fila principal.

Para saber mais sobre o rastreamento de pedidos, consulte a [documentação de pedidos da carteira da Apple](https://developer.apple.com/documentation/walletorders).

#### Swift

```swift
extension CheckoutViewController {
    func applePayContext(_ context: STPApplePayContext, willCompleteWithResult authorizationResult: PKPaymentAuthorizationResult) async -> PKPaymentAuthorizationResult {
        // Fetch the order details from your service
        do {
          let myOrderDetails = try await MyAPIClient.shared.fetchOrderDetails(orderID: myOrderID)
          authorizationResult.orderDetails = PKPaymentOrderDetails(
            orderTypeIdentifier: myOrderDetails.orderTypeIdentifier, // "com.myapp.order"
            orderIdentifier: myOrderDetails.orderIdentifier, // "ABC123-AAAA-1111"
            webServiceURL: myOrderDetails.webServiceURL, // "https://my-backend.example.com/apple-order-tracking-backend"
            authenticationToken: myOrderDetails.authenticationToken // "abc123"
          )
          // Return your modified PKPaymentAuthorizationResult
          return authorizationResult
        } catch {
          return PKPaymentAuthorizationResult(status: .failure, errors: [error])
        }
    }
}
```


# iOS React Native

> This is a iOS React Native for when platform is react-native. View the full page at https://docs.stripe.com/apple-pay?platform=react-native.

Você pode usar o SDK da Stripe para [React Native](https://github.com/stripe/stripe-react-native) para aceitar tanto Apple Pay quanto pagamentos tradicionais com cartão de crédito. Antes de começar, você precisa se inscrever no [Programa de Desenvolvedores da Apple](https://developer.apple.com/programs/) e [configurar a Stripe no servidor e no aplicativo](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=mobile&platform=react-native#react-native-setup). Em seguida, siga estas etapas:

1. [Solicitar um ID de comerciante da Apple](https://docs.stripe.com/apple-pay.md#merchantid)
1. [Criar um certificado Apple Pay](https://docs.stripe.com/apple-pay.md#csr)
1. [Integrar com Xcode](https://docs.stripe.com/apple-pay.md#xcode-pay)
1. [Configurar o ID de comerciante da Apple no StripeProvider](https://docs.stripe.com/apple-pay.md#set-merchantid)
1. [Verificar se Apple Pay é aceito](https://docs.stripe.com/apple-pay.md#check-if-apple-pay-supported)
1. [Apresentar a descrição da compra](https://docs.stripe.com/apple-pay.md#present-payment-sheet)
1. [Enviar o pagamento à Stripe](https://docs.stripe.com/apple-pay.md#handle-payment)

> Se você usa o React Native e a Expo, a Expo Go não é compatível com Apple Pay. Para usar o Apple Pay com a Expo, é preciso criar uma [versão de desenvolvimento](https://docs.expo.dev/get-started/set-up-your-environment/?mode=development-build&platform=ios). Se você já tem um projeto da Expo Go, pode [migrá-lo para uma versão de desenvolvimento](https://docs.expo.dev/develop/development-builds/expo-go-to-dev-build/).

## Solicitar um ID de comerciante da Apple

Obtenha um ID de comerciante da Apple [solicitando um novo identificador](https://developer.apple.com/account/resources/identifiers/add/merchant) no site de desenvolvedores da Apple.

Preencha o formulário com descrição e identificador. A descrição é para seu controle e pode ser modificada no futuro. A Stripe recomenda que você use o nome do aplicativo como identificador (por exemplo, `merchant.com.{{YOUR_APP_NAME}}`).

## Criar um certificado do Apple Pay

Crie um certificado para criptografia de dados de pagamento pelo aplicativo.

Vá até [Configurações de certificado do iOS](https://dashboard.stripe.com/settings/ios_certificates) no Dashboard, clique em **Adicionar novo aplicativo** e siga o guia.

Baixe um arquivo de solicitação de assinatura de certificado (CSR) para obter um certificado seguro da Apple que permite usar o Apple Pay.

Um arquivo CSR deve ser usado para emitir exatamente um certificado. Se você trocar seu ID de comerciante da Apple, acesse as [Configurações de certificado do iOS](https://dashboard.stripe.com/settings/ios_certificates) no Dashboard para obter um novo CSR e certificado.

## Integrar com Xcode

Adicione as funções do Apple Pay ao aplicativo. No Xcode, abra as configurações do projeto, clique na guia **Signing & Capabilities** e adicione o recurso **Apple Pay**. Talvez seja necessário fazer login na sua conta de desenvolvedor. Selecione o ID de comerciante criado anteriormente e o aplicativo já pode aceitar Apple Pay.
![](https://b.stripecdn.com/docs-statics-srv/assets/xcode.a701d4c1922d19985e9c614a6f105bf1.png)

Habilitar o recurso Apple Pay no Xcode

## Configurar o ID de comerciante da Apple no StripeProvider

No componente `StripeProvider`, especifique o ID de comerciante da Apple que você solicitou:

```jsx
import { StripeProvider } from '@stripe/stripe-react-native';

function App() {
  return (
    <StripeProvider
      publishableKey="<<YOUR_PUBLISHABLE_KEY>>"
      merchantIdentifier="merchant.com.{{YOUR_APP_NAME}}"
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

## Verificar se o Apple Pay é aceito

Antes de mostrar o Apple Pay como forma de pagamento no aplicativo, verifique se o dispositivo do usuário aceita Apple Pay e se o usuário adicionou um cartão à sua carteira:

```jsx
import { PlatformPayButton, isPlatformPaySupported } from '@stripe/stripe-react-native';

function PaymentScreen() {
  const [isApplePaySupported, setIsApplePaySupported] = useState(false);

  useEffect(() => {
    (async function () {
      setIsApplePaySupported(await isPlatformPaySupported());
    })();
  }, [isPlatformPaySupported]);

  // ...

  const pay = async () => {
    // ...
  };

  // ...

  return (
    <View>
      {isApplePaySupported && (
        <PlatformPayButton
          onPress={pay}
          type={PlatformPay.ButtonType.Order}
          appearance={PlatformPay.ButtonStyle.Black}
          borderRadius={4}
          style={{
            width: '100%',
            height: 50,
          }}
        />
      )}
    </View>
  );
}
```

## Criar o Payment Intent

### Lado do servidor

Crie um endpoint que crie um PaymentIntent com um [valor](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-amount) e uma [moeda](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-currency). Sempre decida quanto cobrar do lado do servidor, um ambiente seguro, em vez do lado do cliente. Isso evita que clientes mal-intencionados possam escolher os preços.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd"
```

### Do lado do cliente

Crie um método que solicite um PaymentIntent do seu servidor:

```jsx
function PaymentScreen() {
  // ...
  const fetchPaymentIntentClientSecret = async () => {
    const response = await fetch(`${API_URL}/create-payment-intent`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        some: 'value',
      }),
    });
    const { clientSecret } = await response.json();

    return clientSecret;
  };
  // ...
}
```

### Solução de problemas

Quando ocorrem erros da API Stripe durante a criação de tokens, é provável que o problema esteja no certificado do Apple Pay. Gere um novo certificado e carregue-o na Stripe, como descrito nesta página. Use um CSR obtido do Dashboard (não use certificados gerados por você mesmo). Muitas vezes, o Xcode armazena incorretamente certificados antigos no cache. Por isso, além de gerar um novo certificado, a Stripe recomenda que você também crie outro ID de comerciante da Apple.

O erro:

> Você não adicionou a conta de comerciante da Apple à Stripe

pode indicar que o aplicativo está enviando dados criptografados com um CSR/certificado anterior (que não é da Stripe). No seu ID de comerciante da Apple, revogue todos os certificados gerados por CSRs que não sejam da Stripe . Se o erro persistir, exclua o ID de comerciante da conta Apple e crie o ID novamente. Em seguida, crie um certificado baseado no mesmo CSR (fornecido pela Stripe) usando anteriormente. Não é necessário carregar esse novo certificado para a Stripe. Para concluir, desative e ative as credenciais do Apple Pay no aplicativo para atualizá-las.

## Apresentar a descrição da compra

Na [`PlatformPayButton` ](https://stripe.dev/stripe-react-native/api-reference/index.html#PlatformPayButton), no `onPress` chame `confirmPlatformPayPayment` para abrir a folha do Apple Pay. Para exibir os itens do carrinho do cliente na folha de pagamento, passe os itens como argumento. O último item deve representar sua empresa e o total; ele aparece na folha com a palavra “Pay” antes do valor (por exemplo, “Pay iHats, Inc. 50 USD”).

> No código que gerencia a ação do cliente, não inclua ações complexas ou assíncronas antes de exibir a descrição do pagamento. Se a ação do usuário não invocar diretamente a descrição do pagamento, o Apple Pay retorna um erro.

```jsx
import { confirmPlatformPayPayment } from '@stripe/stripe-react-native';

function PaymentScreen() {
  // ... see above

  const pay = async () => {
    const clientSecret = await fetchPaymentIntentClientSecret()
    const { error, paymentIntent } = await confirmPlatformPayPayment(
      clientSecret,
      {
        applePay: {
          cartItems: [
            {
              label: 'Example item name',
              amount: '14.00',
              paymentType: PlatformPay.PaymentType.Immediate,
            },
            {
              label: 'Tax',
              amount: '1.60',
              paymentType: PlatformPay.PaymentType.Immediate,
            },
            {
              label: 'iHats, Inc.',
              amount: '15.60',
              paymentType: PlatformPay.PaymentType.Immediate,
            },
          ],
          merchantCountryCode: 'US',
          currencyCode: 'USD',
          requiredShippingAddressFields: [
            PlatformPay.ContactField.PostalAddress,
          ],
          requiredBillingContactFields: [PlatformPay.ContactField.PhoneNumber],
        },
      }
    );
    if (error) {
      // handle error
    } else {
      Alert.alert('Success', 'Check the logs for payment intent details.');
      console.log(JSON.stringify(paymentIntent, null, 2));
    }
  };

  // ... see above
}
```

## Optional: Criar uma forma de pagamento [Do lado do cliente]

Se você confirmar seu pagamento no servidor, poderá usar Apple Pay somente para coletar um `PaymentMethod` em vez de confirmar um pagamento. Para fazer isso, chame o método `createPlatformPayPaymentMethod`:

```javascript
import {PlatformPayButton, isPlatformPaySupported, createPlatformPayPaymentMethod} from '@stripe/stripe-react-native';

function PaymentScreen() {
  const [isApplePaySupported, setIsApplePaySupported] = useState(false);

  useEffect(() => {
    (async function () {
      setIsApplePaySupported(await isPlatformPaySupported());
    })();
  }, [isPlatformPaySupported]);

  const createPaymentMethod = async () => {
    const { error, paymentMethod } = await createPlatformPayPaymentMethod({
      applePay: {
        cartItems: [
          {
            label: 'Example item name',
            amount: '14.00',
            paymentType: PlatformPay.PaymentType.Immediate,
          },
          {
            label: 'Total',
            amount: '12.75',
            paymentType: PlatformPay.PaymentType.Immediate,
          },
        ],
        merchantCountryCode: 'US',
        currencyCode: 'USD',
      },
    });

    if (error) {
      Alert.alert(error.code, error.message);
      return;
    } else if (paymentMethod) {
      Alert.alert(
        'Success',
        `The payment method was created successfully. paymentMethodId: ${paymentMethod.id}`
      );
    }
  };

  return (
    <View >
      {isApplePaySupported && (
        <PlatformPayButton
          onPress={createPaymentMethod}
          type={PlatformPay.ButtonType.SetUp}
          appearance={PlatformPay.ButtonStyle.WhiteOutline}
          style={{
            width: '65%',
            height: 50,
          }}
        />
      )}
    </View>
  );
}
```

## Optional: Pagamentos recorrentes [Do lado do cliente]

No iOS 16 ou posterior, é possível adotar [tokens de comerciante](https://developer.apple.com/apple-pay/merchant-tokens/) definindo o campo `request` no objeto de parâmetros `confirmPlatformPayPayment()`'s e `confirmPlatformPaySetupIntent`’s  `applePay`.

```js
await confirmPlatformPayPayment(
  clientSecret,
  {
    applePay: {
      // Make sure to include the rest of the necessary fields
      request: {
        type: PlatformPay.PaymentRequestType.Recurring,
        description: 'String describing my payment',
        managementUrl:
          'www.<a URL where the user can update the payment method for the recurring payment>.com',
        billing: {
          paymentType: PlatformPay.PaymentType.Recurring,
          intervalUnit: PlatformPay.IntervalUnit.Month,
          intervalCount: 3,
          label: 'My label',
          amount: '39.00',
        },
      },
    },
  }
);
```

Para saber mais sobre como usar pagamentos recorrentes com o Apple Pay, consulte a [documentação do PassKit da Apple](https://developer.apple.com/documentation/passkit/pkpaymentrequest).

## Optional: Rastreamento de pedidos [Do lado do cliente]

Para adotar o [rastreamento de pedidos](https://developer.apple.com/design/human-interface-guidelines/technologies/wallet/designing-order-tracking) em iOS 16 ou posterior, use o callback `setOrderTracking` para o componente `PlatformPayButton`.

Em sua implementação:

1. Obtenha em seu servidor os detalhes do pedido concluído.
1. Chame o gerenciador de conclusão informado em `setOrderTracking` com os resultados do seu servidor.

```jsx
<PlatformPayButton
  // Make sure to include the rest of the necessary props
  setOrderTracking={(completion) => {
    const { orderIdentifier, orderType, authToken, webServiceUrl } =
      fetchOrderDetailsFromMyBackend();
    completion(orderIdentifier, orderType, authToken, webServiceUrl);
  }}
/>
```

Para saber mais sobre o rastreamento de pedidos, consulte a [documentação de pedidos da carteira da Apple](https://developer.apple.com/documentation/walletorders).


# Web

> This is a Web for when platform is web. View the full page at https://docs.stripe.com/apple-pay?platform=web.

Você pode aceitar pagamentos com Apple Pay na Web usando o [Checkout](https://docs.stripe.com/payments/checkout.md) ou o [Elements](https://docs.stripe.com/payments/elements.md). Não é necessária nenhuma configuração adicional para usar o Apple Pay no Checkout. Para o Elements, consulte os guias [Express Checkout Element](https://docs.stripe.com/elements/express-checkout-element.md) ou [Como aceitar um pagamento](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=checkout) para saber como adicionar o Apple Pay ao seu site.

### Considerações sobre integração da web

- **Usar um iframe com [Elements](https://docs.stripe.com/payments/elements.md)**: quando usar um iframe, sua origem precisa corresponder à origem de nível superior (exceto Safari 17+ quando especificar o atributo `allow="payment"`). Duas páginas têm a mesma origem se o protocolo, host (nome completo do domínio) e porta (se especificada) forem os mesmos para ambas as páginas.
- **Domínio de nível superior e domínio de iframe**: se o domínio de nível superior diferir do domínio do iframe, o domínio de nível superior e o domínio de origem do iframe devem ser [domínios de forma de pagamento registrados](https://docs.stripe.com/payments/payment-methods/pmd-registration.md) na conta associada.
- **Integrações existentes do Stripe.js v2**: faça upgrade para o Checkout ou Elements quando puder.
- **Using [Checkout](https://docs.stripe.com/payments/checkout.md) with [ui_mode](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-ui_mode) set to `embedded_page`**: Supports only Safari version 17 or later and iOS version 17 or later.

O uso do Apple Pay na web está sujeito aos [termos de serviço do Apple Pay na Web](https://stripe.com/apple-pay/legal).

### Registre seu domínio com Apple Pay

Para usar o Apple Pay, você deve registrar todos os seus domínios da web que mostram um botão do Apple Pay junto à Apple. Isso inclui domínios de nível superior (por exemplo, **stripe.com**) e subdomínios (por exemplo, **shop.stripe.com**), em produção e teste.

> #### Subdomínios
> 
> `www` é um subdomínio (por exemplo, **www.stripe.com**) que você também deve registrar.

A Stripe processa a validação de comerciante da Apple para você, incluindo a criação de um ID de comerciante da Apple e uma Solicitação de assinatura de certificado. Não siga o processo de validação de comerciante na documentação do Apple Pay. Em vez disso, siga esta etapa:

1. Instrua a Stripe a registrar seu domínio com a Apple. Isso pode ser feito na [página Domínios de formas de pagamento](https://dashboard.stripe.com/settings/payment_method_domains) no Dashboard *ou* usando a API com sua chave secreta em modo de produção, como mostrado abaixo. Não registre seu domínio mais de uma vez por conta.

```curl
curl https://api.stripe.com/v1/payment_method_domains \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "domain_name=example.com"
```

Ao utilizar [Direct Charges](https://docs.stripe.com/connect/direct-charges.md) em conjunto com o *Connect* (Connect is Stripe's solution for multi-party businesses, such as marketplace or software platforms, to route payments between sellers, customers, and other recipients), é necessário configurar o domínio individualmente para cada conta conectada via API. Esse passo não se aplica a contas que utilizam modalidades distintas de cobrança.

Após registrar seus domínios, faça pagamentos no seu site com as chaves de API em modo de produção.

## Pagamentos recorrentes

Recomendamos implementar tokens de comerciante do Apple Pay para viabilizar transações iniciadas pelo comerciante (MIT), como pagamentos recorrentes e postergados e recargas automáticas. Os tokens de comerciante (MPANs) conectam a sua empresa à forma de pagamento Apple Wallet do cliente, por isso funcionam em vários dispositivos e mantêm as informações de pagamento ativas em um novo dispositivo mesmo quando elas são removidas de um dispositivo perdido ou roubado. Consulte [tokens de comerciante do Apple Pay](https://docs.stripe.com/apple-pay/merchant-tokens.md?pay-element=ece) para ver detalhes da integração.


## Testar Apple Pay

Para testar o Apple Pay, use um número de cartão de crédito real e suas [chaves de API](https://docs.stripe.com/keys.md) de teste. A Stripe reconhece que você está testando e retorna um token de cartão de teste para que possa fazer pagamentos de teste em um cartão em modo de produção sem cobrá-lo.

Não é possível salvar [cartões de teste da Stripe](https://docs.stripe.com/testing.md#use-test-cards) ou [cartões de teste da Apple Pay](https://developer.apple.com/apple-pay/sandbox-testing/) em carteiras da Apple Pay para testar o Apple Pay.

# Web

> This is a Web for when platform is web. View the full page at https://docs.stripe.com/apple-pay?platform=web.

Se você não cumprir os requisitos de dispositivo e integração, a Stripe não mostrará o Apple Pay como opção de pagamento. Use nossa [página de teste](https://docs.stripe.com/testing/wallets.md) para solucionar problemas.


## See also

- [Integração iOS](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=mobile&platform=ios)
- [Apple Pay na Web](https://docs.stripe.com/elements/express-checkout-element.md)
- [Práticas recomendadas do Apple Pay](https://docs.stripe.com/apple-pay/best-practices.md)