Link Android SDK

The Plaid Link SDK is a quick and secure way to link bank accounts to Plaid in your Android app. Link is a drop-in module that handles connecting a financial institution to your app (credential validation, multi-factor authentication, error handling, etc.), without passing sensitive personal information to your server.

To get started with Plaid Link for Android, clone the GitHub repository and try out the example application, which provides a reference implementation in both Java and Kotlin. Youʼll want to sign up for free API keys through the Plaid Dashboard to get started.

Before writing code using the SDK, you must first perform some setup steps to register your app with Plaid and configure your project.

To register your Android app ID:

1. Sign in to the Plaid Dashboard and go to the Developers -> API page.
2. Next to Allowed Android Package Names click Configure then Add New Android Package Name.
3. Enter your package name, for example com.plaid.example.
4. Click Save Changes.

Your Android app is now set up and ready to start integrating with the Plaid SDK.

In your root-level (project-level) Gradle file (build.gradle), add rules to include the Android Gradle plugin. Check that you have Google's Maven repository as well.

1buildscript {
2    repositories {
3        // Check that you have the following line (if not, add it):
4        google()  // Google's Maven repository
5        mavenCentral() // Include to import Plaid Link Android SDK
6    }
7    dependencies {
8        // ...
9    }
10}

In your module (app-level) Gradle file (usually app/build.gradle), add a line to the bottom of the file. The latest version of the PlaidLink SDK is and can be found on Maven Central.

1android {
2  defaultConfig {
3    minSdkVersion 21 // or greater
4  }
5}
6
7dependencies {
8  // ...
9  implementation 'com.plaid.link:sdk-core:<insert latest version>'
10}

If your app uses Identity Verification, a user may need to take a picture of identity documentation or a selfie during the Link flow. To support this workflow, the CAMERA , WRITE_EXTERNAL_STORAGE, RECORD_AUDIO, and MODIFY_AUDIO_SETTINGS permissions need to be added to your application's AndroidManifest.xml. (While Plaid does not record any audio, some older Android devices require these last two permissions to use the camera.) The WRITE_EXTERNAL_STORAGE permission should be limited to < Android 9 (i.e. maxSdk=28). If these permissions are not granted in an app that uses Identity Verification, the app may crash during Link.

Before you can open Link, you need to first create a link_token by calling /link/token/create from your backend. This call should never happen directly from the mobile client, as it risks exposing your API secret. The /link/token/create call must include the android_package_name parameter, which should match the applicationId from your app-level build.gradle file. You can learn more about applicationId in Google's Android developer documentation.

1const request: LinkTokenCreateRequest = {
2  user: {
3    client_user_id: 'user-id',
4  },
5  client_name: 'Plaid Test App',
6  products: ['auth', 'transactions'],
7  country_codes: ['GB'],
8  language: 'en',
9  webhook: 'https://sample-web-hook.com',
10  android_package_name: 'com.plaid.example'
11  },
12};
13try {
14  const response = await plaidClient.linkTokenCreate(request);
15  const linkToken = response.data.link_token;
16} catch (error) {
17  // handle error
18}

Each time you open Link, you will need to get a new link_token from your server and create a new LinkTokenConfiguration object with it.

1val linkTokenConfiguration = linkTokenConfiguration {
2  token = "LINK_TOKEN_FROM_SERVER"
3}

The Link SDK runs as a separate Activity within your app. In order to return the result to your app, it supports both the standard startActivityForResult and onActivityResult and the ActivityResultContract result APIs.

1private val linkAccountToPlaid =
2registerForActivityResult(FastOpenPlaidLink()) {
3  when (it) {
4    is LinkSuccess -> /* handle LinkSuccess */
5    is LinkExit -> /* handle LinkExit */
6  }
7}

1val plaidHandler: PlaidHandler = 
2  Plaid.create(application, linkTokenConfiguration)

1linkAccountToPlaid.launch(plaidHandler)

At this point, Link will open, and will trigger the onSuccess callback if the user successfully completes the Link flow.

1val success = result as LinkSuccess
2
3// Send public_token to your server, exchange for access_token 
4// (if using Item-based products)
5val publicToken = success.publicToken
6val metadata = success.metadata
7metadata.accounts.forEach { account ->
8  val accountId = account.id
9  val accountName = account.name
10  val accountMask = account.mask
11  val accountSubType = account.subtype
12}
13val institutionId = metadata.institution?.id
14val institutionName = metadata.institution?.name

1val exit = result as LinkExit
2
3val error = exit.error
4error?.let { err ->
5  val errorCode = err.errorCode
6  val errorMessage = err.errorMessage
7  val displayMessage = err.displayMessage
8}
9val metadata = exit.metadata
10val institutionId = metadata.institution?.id
11val institutionName = metadata.institution?.name
12val linkSessionId = metadata.linkSessionId;
13val requestId = metadata.requestId;

1Plaid.setLinkEventListener { event -> Log.i("Event", event.toString()) }

1val submissionData = SubmissionData(phoneNumber)
2plaidHandler.submit(submissionData)

The latest version of the SDK is available from GitHub. New versions of the SDK are released frequently. Major releases occur annually. The Link SDK uses Semantic Versioning, ensuring that all non-major releases are non-breaking, backwards-compatible updates. We recommend you update regularly (at least once a quarter, and ideally once a month) to ensure the best Plaid Link experience in your application.

SDK versions are supported for two years; with each major SDK release, Plaid will stop officially supporting any previous SDK versions that are more than two years old. While these older versions are expected to continue to work without disruption, Plaid will not provide assistance with unsupported SDK versions.

If you run into problems integrating with Plaid Link on Android, see Troubleshooting the Plaid Link Android SDK.

Once you've gotten Link working, see Link best practices for recommendations on further improving the Link flow.