Quick Start Guide

The Accept SDK runs inside your app and handles payments on the device: it captures the card or Tap to Pay, encrypts the data, and keeps card handling out of your code so you stay outside PCI scope. Your backend authenticates each SDK session against the Tapaya API, onboards merchants, and triggers KYB. Tapaya runs the KYB checks and settles funds to the merchant.

Choose Your Integration Path

There are two ways to take card payments with Tap to Pay. Both hand the actual card interaction off to the Tapaya Terminal plugin app on the same device. They differ in how much of that handoff your app manages:

• Accept SDK (this guide): embed the Tapaya Accept SDK in your app. The SDK creates the payment, launches Tapaya Terminal, and delivers the result to your onResult/onError callbacks. This is the recommended path for native Android apps and is what the rest of this guide walks through.
• Tapaya Terminal app only, no SDK: if you can't embed the Accept SDK (a cross-platform framework without native bindings, a thin POS shell, a WebView-based till), you can drive the Tapaya Terminal app directly with an Android intent or a deeplink. In this mode your backend creates the payment and your app polls its status, instead of relying on SDK callbacks. See Integrate without the SDK for the intent and deeplink contracts.

Create Your Tapaya Account

Before writing any code, set up the account your backend will authenticate against:

1. Sign up at platform.tapaya.com/register. This is self-serve: no invite is required.
2. Log in, then create or join your organization; you'll be prompted for this automatically right after registering.
3. Generate your Server Secret Token from the API Keys page: your backend uses this to call the Tapaya Platform API (see API Integration).

The rest of this guide covers adding the SDK to your project, authenticating a session, and running your first transaction.

dependencies {
    implementation("com.tapaya:accept:1.10.0")
}

// Step 1: Initialize (once, in Application.onCreate)
Accept.initialize(this) // sandbox by default; pass isProduction = true to go live

// Step 2: Authenticate (suspend; call from a coroutine)
try {
    val merchantToken = myBackend.login() // fetch from your backend
    Accept.auth.authenticate(merchantToken)
    // Accept.state now emits SdkState.Authenticated
} catch (e: AcceptException) {
    // handle authentication failure
}

val ready = when (val status = Accept.merchant.onboardingStatus()) {
    OnboardingStatus.ReadyForPayments -> true
    is OnboardingStatus.RequiresAction -> false // status.state describes what's blocking
}

if (Accept.plugin.isInstalled()) {
    // suspend; returns ActivateTerminalResult (Success / Canceled / Failed)
    Accept.plugin.activateTerminal()
} else {
    Accept.plugin.install() // opens the store listing
}

Accept.payments.pay(amount = 15000, currency = "CZK") // 150.00 Kč
    .collect { event ->
        when (event) {
            PaymentEvent.Creating -> Log.d("pay", "creating")
            is PaymentEvent.Created -> Log.d("pay", "created ${event.paymentToken}")
            PaymentEvent.Launched -> Log.d("pay", "launched")
            is PaymentEvent.Result -> Log.d("pay", event.payResult.toString())
            is PaymentEvent.CreationFailed -> Log.e("pay", event.cause.toString())
        }
    }