@capacitor-community/stripe-terminal

Stripe SDK bindings for Capacitor Applications. This plugin is still in beta. We have confirmed that it works well in the demo project. Please refer to https://github.com/capacitor-community/stripe/tree/main/demo/angular for the implementation.

• [x] Tap To Pay
• [x] Internet
• [x] Bluetooth
• [x] USB

Install

npm install @capacitor-community/stripe-terminal
npx cap sync

iOS

• iOS Configure your app

Android

Add permissions to your android/app/src/main/AndroidManifest.xml file:

+ <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+ <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
+ <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
+ <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
+ <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
+ <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

If used in conjunction with the @capacitor-community/stripe plugin, the following settings may be necessary

Add packagingOptions to your android/app/build.gradle file:

android {
...
+  packagingOptions {
+    resources.excludes.add("org/bouncycastle/x509/*")
+  }
}

And update minSdkVersion to 26 And compileSdkVersion to 34 in your android/app/build.gradle file:

  ext {
-    minSdkVersion = 22
-    compileSdkVersion = 33
+    minSdkVersion = 30
+    compileSdkVersion = 34

Usage

use native http client for getting a token

(async ()=> {
  /**
   * tokenProviderEndpoint: The URL of your backend to provide a token. Use Post request to get a token.
   */
  await StripeTerminal.initialize({ tokenProviderEndpoint: 'https://example.com/token', isTest: true })
  const { readers } = await StripeTerminal.discoverReaders({
    type: TerminalConnectTypes.TapToPay,
    locationId: "**************",
  });
  await StripeTerminal.connectReader({
    reader: readers[0],
  });
  // Collect payment intent
  await StripeTerminal.collectPaymentMethod({ paymentIntent: "**************" });
  // Process and confirm payment intent
  await StripeTerminal.confirmPaymentIntent();
  // disconnect reader
  await StripeTerminal.disconnectReader();
});

set string token

(async ()=> {
  // run before StripeTerminal.initialize
  StripeTerminal.addListener(TerminalEventsEnum.RequestedConnectionToken, async () => {
    const { token } = (await fetch("https://example.com/token")).json();
    StripeTerminal.setConnectionToken({ token });
  });
});
(async ()=> {
  await StripeTerminal.initialize({ isTest: true })
  const { readers } = await StripeTerminal.discoverReaders({
    type: TerminalConnectTypes.TapToPay,
    locationId: "**************",
  });
  await StripeTerminal.connectReader({
    reader: readers[0],
  });
  // Collect payment intent
  await StripeTerminal.collectPaymentMethod({ paymentIntent: "**************" });
  // Process and confirm payment intent
  await StripeTerminal.confirmPaymentIntent();
  // disconnect reader
  await StripeTerminal.disconnectReader();
});

API

• initialize(...)
• discoverReaders(...)
• setConnectionToken(...)
• connectReader(...)
• getConnectedReader()
• disconnectReader()
• cancelDiscoverReaders()
• collectPaymentMethod(...)
• cancelCollectPaymentMethod()
• confirmPaymentIntent()
• addListener(TerminalEventsEnum.Loaded, ...)
• addListener(TerminalEventsEnum.RequestedConnectionToken, ...)
• addListener(TerminalEventsEnum.DiscoveredReaders, ...)
• addListener(TerminalEventsEnum.ConnectedReader, ...)
• addListener(TerminalEventsEnum.ConfirmedPaymentIntent, ...)
• addListener(TerminalEventsEnum.CollectedPaymentIntent, ...)
• addListener(TerminalEventsEnum.Canceled, ...)
• addListener(TerminalEventsEnum.Failed, ...)
• Interfaces
• Type Aliases
• Enums

initialize(...)

initialize(options: { tokenProviderEndpoint?: string; isTest: boolean; }) => Promise<void>

Param	Type
options	{ tokenProviderEndpoint?: string; isTest: boolean; }

---

discoverReaders(...)

discoverReaders(options: { type: TerminalConnectTypes; locationId?: string; }) => Promise<{ readers: ReaderInterface[]; }>

Param	Type
options	{ type: TerminalConnectTypes; locationId?: string; }

Returns: Promise<{ readers: ReaderInterface[]; }>

---

setConnectionToken(...)

setConnectionToken(options: { token: string; }) => Promise<void>

Param	Type
options	{ token: string; }

---

connectReader(...)

connectReader(options: { reader: ReaderInterface; }) => Promise<void>

Param	Type
options	{ reader: ReaderInterface; }

---

getConnectedReader()

getConnectedReader() => Promise<{ reader: ReaderInterface | null; }>

Returns: Promise<{ reader: ReaderInterface | null; }>

---

disconnectReader()

disconnectReader() => Promise<void>

---

cancelDiscoverReaders()

cancelDiscoverReaders() => Promise<void>

---

collectPaymentMethod(...)

collectPaymentMethod(options: { paymentIntent: string; }) => Promise<void>

Param	Type
options	{ paymentIntent: string; }

---

cancelCollectPaymentMethod()

cancelCollectPaymentMethod() => Promise<void>

---

confirmPaymentIntent()

confirmPaymentIntent() => Promise<void>

---

addListener(TerminalEventsEnum.Loaded, ...)

addListener(eventName: TerminalEventsEnum.Loaded, listenerFunc: () => void) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.Loaded
listenerFunc	() => void

Returns: PluginListenerHandle

---

addListener(TerminalEventsEnum.RequestedConnectionToken, ...)

addListener(eventName: TerminalEventsEnum.RequestedConnectionToken, listenerFunc: () => void) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.RequestedConnectionToken
listenerFunc	() => void

Returns: PluginListenerHandle

---

addListener(TerminalEventsEnum.DiscoveredReaders, ...)

addListener(eventName: TerminalEventsEnum.DiscoveredReaders, listenerFunc: () => { reader: ReaderInterface; }) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.DiscoveredReaders
listenerFunc	() => { reader: ReaderInterface; }

Returns: PluginListenerHandle

---

addListener(TerminalEventsEnum.ConnectedReader, ...)

addListener(eventName: TerminalEventsEnum.ConnectedReader, listenerFunc: () => void) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.ConnectedReader
listenerFunc	() => void

Returns: PluginListenerHandle

---

addListener(TerminalEventsEnum.ConfirmedPaymentIntent, ...)

addListener(eventName: TerminalEventsEnum.ConfirmedPaymentIntent, listenerFunc: () => void) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.ConfirmedPaymentIntent
listenerFunc	() => void

Returns: PluginListenerHandle

---

addListener(TerminalEventsEnum.CollectedPaymentIntent, ...)

addListener(eventName: TerminalEventsEnum.CollectedPaymentIntent, listenerFunc: () => void) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.CollectedPaymentIntent
listenerFunc	() => void

Returns: PluginListenerHandle

---

addListener(TerminalEventsEnum.Canceled, ...)

addListener(eventName: TerminalEventsEnum.Canceled, listenerFunc: () => void) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.Canceled
listenerFunc	() => void

Returns: PluginListenerHandle

---

addListener(TerminalEventsEnum.Failed, ...)

addListener(eventName: TerminalEventsEnum.Failed, listenerFunc: () => void) => PluginListenerHandle

Param	Type
eventName	TerminalEventsEnum.Failed
listenerFunc	() => void

Returns: PluginListenerHandle

---

Interfaces

PluginListenerHandle

Prop	Type
remove	() => Promise<void>

Type Aliases

ReaderInterface

{ index: number; serialNumber: string; }

Enums

TerminalConnectTypes

Members	Value
Simulated	'simulated'
Internet	'internet'
Bluetooth	'bluetooth'
Usb	'usb'
TapToPay	'tap-to-pay'

TerminalEventsEnum

Members	Value
Loaded	'terminalLoaded'
DiscoveredReaders	'terminalDiscoveredReaders'
CancelDiscoveredReaders	'terminalCancelDiscoveredReaders'
ConnectedReader	'terminalConnectedReader'
DisconnectedReader	'terminalDisconnectedReader'
ConfirmedPaymentIntent	'terminalConfirmedPaymentIntent'
CollectedPaymentIntent	'terminalCollectedPaymentIntent'
Canceled	'terminalCanceled'
Failed	'terminalFailed'
RequestedConnectionToken	'terminalRequestedConnectionToken'