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). All 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 Developer Dashboard to get started.

• Android Studio 4.0 or above
• A Plaid client_id and secret, available from the Plaid Dashboard
• Android 5.0 (API level 21) or above

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.

buildscript {
    repositories {
        // Check that you have the following line (if not, add it):
        google()  // Google's Maven repository
        mavenCentral() // Include to import Plaid Link Android SDK
        jcenter() // Include to import Plaid Link transitive dependencies
    }
    dependencies {
        // ...
    }
}

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.

android {
  defaultConfig {
    minSdkVersion 21 // or greater
  }
  // Enable Java 8 support for Link to work
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}
dependencies {
  // ...
  implementation 'com.plaid.link:sdk-core:<insert latest version>'
}

To register your Android app ID:

1. Log into your Plaid Dashboard at the 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, you may be prompted to re-enter your password

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

Before you can open Link, you need to first create a link_token. A link_token can be configured for different Link flows and is used to control much of Link's behavior. To see how to create a new link_token, see the API Reference entry for /link/token/create. The /link/token/create call should include the android_package_name parameter.

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.

val linkTokenConfiguration = linkTokenConfiguration {
  token = "LINK_TOKEN_FROM_SERVER"
}

Create a PlaidHandler - A PlaidHandler is a one-time use object used to open a Link session. It should be created as early as possible to warm-up Link so that it opens quickly. We recommend doing this as early as possible, since it must be completed before Link opens, and if delayed until just before Link opening it can have a perceptible impact on Link startup time.

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

Finally, open Link by calling open on the PlaidHandler object in an Activity or Fragment. This will usually be done in a button's onClick function.

Note The Activity or Fragment passed in the open function will be used to return the result.

plaidHandler.open(activity)

The Link SDK uses the standard Android startActivityForResult and onActivityResult APIs to show Link and return the result to your application.

First create a LinkResultHandler to parse the result out of the returned intent.

private val linkResultHandler = LinkResultHandler(
  onSuccess = { it: LinkSuccess -> /* handle onSuccess */ },
  onExit = { it: LinkExit -> /* handle onExit */ }
)

Call the onActivityResult function of LinkResultHandler to parse the result. This function will return true if the result if the result was sent from Link and was parsed by the handler.

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
  if (!linkResultHandler.onActivityResult(requestCode, resultCode, data)) {
    Log.i(MainActivity::class.java.simpleName, "Not handled by the LinkResultHandler");
  }
}

private val linkResultHandler = LinkResultHandler(
  // ...
  onSuccess = { it: LinkSuccess ->
    // Send public_token to your server, exchange for access_token
    val publicToken = it.publicToken
    val metadata = it.metadata
    metadata.accounts.forEach { account ->
      val accountId = account.id
      val accountName = account.name
      val accountMask = account.mask
      val accountSubType = account.subtype
    }
    val institutionId = metadata.institution?.id
    val institutionName = metadata.institution?.name
  }
)

private val linkResultHandler = LinkResultHandler(
  // ...
  onExit = {
    val error = it.error
    error?.let { err ->
      val errorCode = err.errorCode
      val errorMessage = err.errorMessage
      val displayMessage = err.displayMessage
    }
    val metadata = it.metadata
    val institutionId = metadata.institution?.id
    val institutionName = metadata.institution?.name
    val linkSessionId = metadata.linkSessionId;
    val requestId = metadata.requestId;
  }
)

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

Using Plaid Link with an OAuth flow requires some additional setup instructions. For details, see the OAuth Guide.

Pass a LinkLogLevel value with the LinkTokenConfiguration to get visible logs. From least to most verbose: ERROR, WARN, INFO, DEBUG, VERBOSE.

val linkTokenConfiguration = linkTokenConfiguration {
  token = "LINK_TOKEN_FROM_SERVER"
  logLevel = if (BuildConfig.DEBUG) LinkLogLevel.VERBOSE else LinkLogLevel.ERROR
}

Please see our GitHub repository for version release notes. Steps to upgrade to the latest version can be found at 2.x to 3.x.