Tap to Pay on iPhone

Integrate MoovKit

Moov's SDK to integrate Tap to Pay on iPhone functionality is available for download and you can find more details in the documentation.

Add MoovKit as a package dependency to your project with Swift Package Manager.

https://github.com/moovfinancial/moov-ios

Within the project you'll also need to embed the framework and link binary with libraries. See the MoovKit documentation for complete details.

And finally, add MoovKit to your project.

import MoovKit

Request entitlement from Apple

Your application must request an entitlement from Apple for Tap to Pay on iPhone. You can request from your Apple Developer Account.

After receiving the entitlement, you should configure the entitlement in your project. View the full instructions on developer.apple.com.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.developer.proximity-reader.payment.acceptance</key>
    <true/>
</dict>
</plist>

Review Apple's guidelines

Implement terminal configuration provider

Implement a terminal configuration provider to initialize MoovKit. For production use, fetch the configuration from your backend. Below is a sample implementation, assuming PartnerClient is implemented to interact with your backend API:

import Foundation
import MoovKit
import PartnerClient
import os

actor TerminalConfigProvider: TerminalConfigurationProvider {
  let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "main")
  
  var terminalConfiguration: String {
    get async throws {
        return try await fetch(terminalApplicationID: TerminalApplicationID("7922ce07-daf3-48f2-aab3-ed878c76a1a3"))
    }
  }

  let partnerClient: PartnerClient
  let merchantAccountID: MerchantAccountID

  public init(partnerClient: PartnerClient, merchantAccountID: MerchantAccountID) {
    self.partnerClient = partnerClient
    self.merchantAccountID = merchantAccountID
  }

  func fetch(terminalApplicationID: TerminalApplicationID) async throws -> String {
    do {            
      let terminalConfig = try await partnerClient.getTerminalConfiguration(
        accountID: merchantAccountID,
        terminalApplicationID: terminalApplicationID
      )
      return terminalConfig.configuration
    } catch {
      logger.error("\(error)")
      throw error
    }
  }
}

let terminalConfigProvider = TerminalConfigProvider(
  partnerClient: partnerClient,
  merchantAccountID: MerchantAccountID("merchant-account-id")
)
let moov = Moov(terminalConfigProvider: terminalConfigProvider)

View the SDK documentation for more details and context.

Register application

Applications must be registered with Moov to be authorized to use MoovKit. The process for application registration is as follows:

1. Create a terminal application via the POST terminal application endpoint.

curl -X POST "https://api.moov.io/terminal-applications" \
  -H "Authorization: Bearer {token}" \
  -H "x-moov-version: v2026.07.00" \
  --data '{
    "platform": "ios",
    "appBundleID": "com.example.app"
  }'

2. The application will move from pending to enabled once approved. You can subscribe to the terminalAppRegistration.updated webhook to be notified of the status updates.

3. Once the application is enabled, you must link the app's terminalApplicationID to a merchant account via the link POST terminal application endpoint.

curl -X POST "https://api.moov.io/accounts/{accountID}/terminal-applications" \
  -H "Authorization: Bearer {token}" \
  -H "x-moov-version: v2026.07.00" \
  --data-raw '{
    "terminalApplicationID": "12345678-1234-1234-1234-123456789012"
  }'

Accept Apple's terms and conditions

Merchants need to accept Apple's terms and conditions - once for each merchant identifier. Once the terms and conditions are accepted, any device using the same merchant identifier can use Tap to Pay on iPhone without accepting the terms and conditions again. The additional devices don’t need to use the same Apple account, or be signed in to Apple.

For the best user experience, it’s recommended to present the terms and conditions before the checkout experience.

View Apple's documentation for more information on terms and conditions.

Accept a payment

1. Once terms and conditions have been accepted, initialize the reader hardware. MoovKit checks the Tap to Pay entitlement during initReader(). If the app is missing the entitlement, the call throws CardReaderError.notAllowed.

do {
  _ = try await moov.initReader()
} catch {
  print("Reader initialization failed")
}

2. Create a payment session by calling createSession(invalidateTerminalConfiguration:) as early as possible to configure the device.

There are two main paths to accept EMV payments:

• Directly create a transfer from the SDK
• Create an authorization via the SDK and create the transfer separately

import Foundation
import MoovKit

do {
  let accessToken = "access-token-from-your-backend"
  let paymentMethodId = PaymentMethodID("destination-payment-method-id")
  let tapAmount = TapAmount(Decimal(string: "10.00")!, currency: .USD)
  let transfer = try await moov.createTapTransfer(
    for: tapAmount,
    transactionType: .purchase, 
    destinationPaymentMethodId: paymentMethodId, 
    customerAccountId: nil, 
    description: nil, 
    using: accessToken
	)
} catch {
	print("Card read error")
}

import Foundation
import MoovKit

do {
  let tapAmount = TapAmount(Decimal(string: "1.23")!, currency: .USD)
  let authResponse = try await moov.createTapAuthorization(
    for: tapAmount,
    transactionType: .purchase,
    customerAccountId: nil
  )
    
// send authResponse.paymentToken to your backend to create a transfer using authorization as the source
} catch {
  print("Card read error")
}

The transfer's source.cardDetails.status moves to confirmed once the card network authorizes it. Subscribe to the transfer.updated webhook to track it to completed. See card transfer statuses.