### Add Dependency [#add-dependency]
On Android the SDK is published to [Maven Central](https://central.sonatype.com/artifact/com.tapaya/accept); set `acceptVersion` to its latest release. On React Native it installs from npm with
`npx expo install @tapayadot/accept-react-native` and is wired up by its config plugin.
Android (Kotlin)
React Native (TypeScript)
```kotlin title="build.gradle.kts"
dependencies {
// [!code ++:1]
implementation("com.tapaya:accept:$acceptVersion")
}
```
```json title="app.json"
{
"expo": {
"plugins": ["@tapayadot/accept-react-native"]
}
}
```
Sync the project (Android) or run `npx expo prebuild --clean` (React Native), then initialize and
authenticate in your application code.
Android (Kotlin)
React Native (TypeScript)
```kotlin title="MyApplication.kt"
// Step 1: Initialize (once, in Application.onCreate)
Accept.initialize(this) // sandbox by default; pass isProduction = true to go live
```
```typescript title="App.tsx"
import Accept from '@tapayadot/accept-react-native';
// Step 1: Initialize (once, at app startup)
Accept.initialize(); // sandbox by default; pass { isProduction: true } to go live
```
Authenticate a merchant session with a token obtained from your backend.
`authenticate` is a `suspend` function and throws an `AcceptException` on failure.
Android (Kotlin)
React Native (TypeScript)
```kotlin
// Step 2: Authenticate (suspend; call from a coroutine)
try {
val sdkToken = myBackend.login() // token from POST /merchant/auth/login
Accept.auth.authenticate(sdkToken)
// Accept.state now emits SdkState.Authenticated
} catch (e: AcceptException) {
// handle authentication failure
}
```
```typescript
// Step 2: Authenticate
try {
const sdkToken = await myBackend.login(); // token from POST /merchant/auth/login
await Accept.auth.authenticate(sdkToken);
// Accept.state is now 'authenticated'
} catch (error) {
// handle authentication failure
}
```
### Onboard the Merchant [#onboard-the-merchant]
Before any transactions are allowed, the merchant must finish KYB onboarding. Onboarding is **no longer
driven by the Accept SDK**. Complete it through the Tapaya Platform UI, your own UI against the Tapaya
API, or an invite link. See [Merchant Onboarding](/merchants/onboarding) for all methods.
In the sandbox environment, merchants are automatically approved right after onboarding, so you don't have to wait for payment processor review.
### Verify Merchant Readiness [#verify-merchant-readiness]
Ensure the merchant has finished onboarding and is approved to accept payments.
Android (Kotlin)
React Native (TypeScript)
```kotlin
val ready = when (val status = Accept.merchant.onboardingStatus()) {
OnboardingStatus.ReadyForPayments -> true
is OnboardingStatus.RequiresAction -> false // status.state describes what's blocking
}
```
```typescript
const status = await Accept.merchant.onboardingStatus();
// status.state describes what's blocking when it requires action
const ready = status.type === 'readyForPayments';
```
The merchant is ready only after the payment processor has approved it. If some information is missing,
the onboarding must be repeated. In some cases, the payment processor might block the merchant completely, such as when selling prohibited goods.
### Install & Activate Terminal [#install--activate-terminal]
Card payments require the **Tapaya Accept** plugin to be installed on the device.
Use `Accept.plugin.isInstalled()` to check, and `Accept.plugin.install()` to open the store
listing if it is missing.
The Tapaya Accept plugin is required for card payments. Check if it is installed, then activate
the terminal, or open the Play Store listing to install it.
Android (Kotlin)
React Native (TypeScript)
```kotlin
if (Accept.plugin.isInstalled()) {
// suspend; returns ActivateTerminalResult (Success / Canceled / Failed)
Accept.plugin.activateTerminal()
} else {
Accept.plugin.install() // opens the store listing
}
```
```typescript
if (Accept.plugin.isInstalled()) {
// returns ActivateTerminalResult: { type: 'success' | 'canceled' | 'failed' }
await Accept.plugin.activateTerminal();
} else {
await Accept.plugin.install(); // opens the store listing
}
```
### Create Payment Transaction [#create-payment-transaction]
To execute a transaction, call `Accept.payments.pay()` with the amount (in the currency's minor unit)
and an ISO 4217 currency code. It returns a `Flow`; collect it to observe progress and
the terminal outcome. `pay()` never throws: failures arrive as `PaymentEvent.CreationFailed`.
The quick start needs only `amount` and `currency`. For every optional parameter, such as a fixed tip, receipt
overrides, or metadata, see [Create a payment](../integration/card_terminal#create-a-payment).
Android (Kotlin)
React Native (TypeScript)
```kotlin
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())
}
}
```
```typescript
// payAsync() reduces the event stream to its outcome; use pay() to render progress
const result = await Accept.payments.payAsync({
amount: 15000,
currency: 'CZK', // 150.00 Kč
});
if (result.type === 'success') {
console.log(result.paymentToken, result.receiptUrl);
}
```