Accept paymentsWays to get paidTap to Pay

Tap to Pay overview

Learn how Tap to Pay lets your app accept contactless, card-present payments with no external hardware

View as MarkdownOpen in Claude
Applies to:DevelopersPartners

Tap to Pay (also called SoftPOS) turns a partner’s phone into a card-present payment terminal. A payor taps their contactless card, phone, or watch against the device. No external card reader is required. Because it’s a card-present transaction, it qualifies for card-present interchange rates. The payment happens inside the partner’s own app, under the partner’s own brand.

Tap to Pay is a payment method, built on Payabli’s mobile SDK. Right now, only iOS is supported. See Tap to Pay for the component reference.

How Tap to Pay works

A Tap to Pay charge moves through six steps, from requesting an access token to receiving a transaction result. Device setup (initializing the SDK) and reading a card happen separately. Initializing the SDK doesn’t touch the card at all:

1

Partner app requests an access token

Before accepting a payment, the partner app asks its own backend for a short-lived Payabli access token. The Payabli clientSecret never leaves the backend.

2

Partner backend exchanges credentials for a token

The backend calls Payabli’s token endpoint with its clientId and clientSecret and returns the resulting access token to the app.

3

App initializes the SDK

The app calls the mobile SDK’s initialize() method, which performs one-time device attestation and prepares the reader. No card is read yet.

4

SDK starts the charge

The app calls charge(). The SDK sends the transaction details to Payabli’s Pay In API, which returns a transaction ID before any card is read.

5

SDK reads the card and gets authorization

The SDK prompts the payor to tap their card, phone, or watch and reads the card. The SDK then sends the card data to the processor, which requests authorization from the card network.

6

SDK confirms the result with Payabli

The SDK notifies Payabli that the payment is complete, and Payabli stores the authorization data with the transaction. The SDK then returns a transaction result to the app, including the paymentTransId used to track the payment in Payabli.

Tap to Pay sequence from access token request through card network authorization
Click to expand

Diagram: Tap to Pay transaction flow

This diagram shows the sequence of calls between the partner app, the partner’s backend, Payabli, the processor, and the card network:

  1. The partner app requests an access token from the partner backend.
  2. The partner backend exchanges its clientId and clientSecret with Payabli for an access token, then returns it to the app.
  3. The app initializes the SDK, which performs device attestation. No card is read yet.
  4. The app starts the charge. Payabli returns a transaction ID before any card is read.
  5. The app reads the payor’s contactless card, phone, or watch over NFC, then sends the card data to the processor, which requests authorization from the card network.
  6. The app notifies Payabli that the payment is complete, and Payabli stores the authorization data with the transaction.
  7. Payabli returns the transaction result, including the paymentTransId, to the partner app.

Supported payment types

Tap to Pay accepts:

  • Tokenized NFC card (digital wallet). A card provisioned into a digital wallet, such as Apple Pay or Google Pay, on a payor’s NFC-capable phone or smartwatch.
  • NFC-enabled card. A physical contactless card from Visa, Mastercard, Discover, or American Express.

Requirements

Tap to Pay requires a physical device. See Accept Tap to Pay payments: Prerequisites for the full checklist, including minimum OS and hardware versions.

First-time device activation

The first time a device runs your app, attestation succeeds but the device is marked pending, and the SDK throws devicePendingActivation. Your backend requests a one-time activation code from Payabli, and your app delivers it to the user by email, SMS, or in-app. After the user enters the code and the app submits it, the device is authorized for all future sessions. See Integration steps for the implementation details.

First-time Tap to Pay device activation sequence from pending device registration through re-initialization
Click to expand

Diagram: First-time device activation

This diagram shows the sequence for activating a device the first time it runs your app:

  1. The app calls initialize(), which asks Payabli’s device service to run an App Attest check.
  2. The device service completes attestation but marks the device as pending.
  3. The app throws devicePendingActivation.
  4. The app calls its own backend, which requests a one-time activation code from Payabli.
  5. The backend returns the activation code and its expiration to the app.
  6. The app delivers the code to the user by email, SMS, or in-app.
  7. The user enters the code in the app.
  8. The app calls activateDevice(activationCode:), which sends the code to Payabli’s device service.
  9. The device service confirms the activation.
  10. The app calls initialize() again.
  11. Because attestation is already cached, initialize() skips straight to fetching configuration and preparing the reader, and the session becomes ready.

Next steps

  • Accept Tap to Pay payments walks through the full Tap to Pay integration, including paypoint registration, Apple entitlements, and device activation.
  • Tap to Pay documents the PayabliSDKTapToPay component, including its full implementation reference and example app.

See these related resources to help you get the most out of Payabli.