Plaid Link for Android


Overview

Introduction

Here you find instructions on how to integrate and use Plaid Link for Android. At the center of it lies PlaidLinkSdk: an embeddable framework managing the details of linking an account with Plaid.

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

Examples of Plaid Link for Android

Requirements

  • Install or update Android Studio to version 3.0 or greater
  • Plaid API keys – you’ll need your Plaid public_key to get started
  • Android 5.0 (API level 21) and above

A new version of Link for Android will be released around the 15th of every month and we highly recommend you keep up to date to provide the best Plaid Link experience in your application.

Getting setup

Update your Project plugins

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.

build.gradle (Project-level)

buildscript {
    repositories {
        // Check that you have the following line (if not, add it):
        google()  // Google's Maven repository
        jcenter() // Include to import Plaid Link dependencies
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.4.2'
    }
}

In your module (app-level) Gradle file (usually app/build.gradle), add a line to the bottom of the file. Source the latest version of the PlaidLink SDK from the com.plaid.link Bintray package.

build.gradle (App-level)

dependencies {
  // ...
  implementation 'com.plaid.link:sdk-core:0.1.3'
}

Edit your app manifest

Add the LinkActivity activity to your AndroidManifest.xml within the application tag. Within the application component, set the link.public_key metadata element to your Plaid public_key, sourced from your Dashboard.

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />

<application>
  // ...
  <activity android:name="com.plaid.link.LinkActivity" />

  <!-- Your public_key from your Plaid dashboard -->
  <!-- We recommend that you define this in the donottranslate.xml file for different build types -->
  <meta-data android:name="com.plaid.link.public_key"
             android:value="[PLAID_PUBLIC_KEY]" />
</application>

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

To integrate PlaidLink inside of your application, follow the steps layed out below:

Initialize the Plaid SDK instance in your Application class’ onCreate method.

MainApplication

import com.plaid.link.Plaid

class MainApplication : Application() {
  override fun onCreate() {
    super.onCreate()

    Plaid.create(this)
  }
}



import com.plaid.link.Plaid;
import com.plaid.linkbase.PlaidOptions;

public class MainApplication extends Application {

  @Override
  public void onCreate() {
    super.onCreate();

    Plaid.create(this);
  }
}

When you want to open Link call startActivityForResult with the correct parameters for your integration and product use. See the Link parameter reference below for complete documentation on possible configurations.

MainActivity

import android.content.Intent

import com.plaid.link.LinkActivity
import com.plaid.link.Plaid
import com.plaid.linkbase.models.LinkConfiguration
import com.plaid.linkbase.models.LinkEventListener
import com.plaid.linkbase.models.PlaidApiError
import com.plaid.linkbase.models.PlaidEnvironment
import com.plaid.linkbase.models.PlaidProduct

class MainActivity : AppCompatActivity() {

  companion object {
    const val LINK_REQUEST_CODE = 1
  }

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val linkConfig = LinkConfiguration(
      // required
      clientName = "My Application name",
      environment = PlaidEnvironment.SANDBOX,
      products = listOf(PlaidProduct.TRANSACTIONS),

      // optional
      linkEventListener = LinkEventListener{},
      language = Locale.ENGLISH.language,
      countryCodes = listOf(Locale.US.country),
      webhook = "https://requestb.in",
      userEmailAddress = "John Appleseed",
      userLegalName = "jappleseed@example.net"
    )

    val intent = Intent(this, LinkActivity::class.java)
    intent.putExtra(Plaid.LINK_CONFIGURATION, linkConfig)

    // Open Link – put this inside of a Button / Fab
    startActivityForResult(intent, LINK_REQUEST_CODE)
  }
}


import java.util.ArrayList;
import android.content.Intent;
import androidx.appcompat.app.AppCompatActivity;

import com.plaid.link.LinkActivity;
import com.plaid.link.Plaid;
import com.plaid.linkbase.models.LinkConfiguration;
import com.plaid.linkbase.models.LinkEventListener;
import com.plaid.linkbase.models.PlaidApiError;
import com.plaid.linkbase.models.PlaidEnvironment;
import com.plaid.linkbase.models.PlaidProduct;

public class MainActivity extends AppCompatActivity {

  private static final int LINK_REQUEST_CODE = 1;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    // required
    String clientName = "My Application name";
    PlaidEnvironment environment = PlaidEnvironment.SANDBOX;
    ArrayList products = new ArrayList<>();
    products.add(PlaidProduct.TRANSACTIONS);

    // optional
    LinkEventListener linkEventListener = {}
    String language = Locale.ENGLISH.language;
    ArrayList countryCodes = new ArrayList<>();
    countryCodes.add(Locale.US.country);
    String webhook = "https://requestb.in";
    String userLegalName = "John Appleseed";
    String userEmailAddress = "jappleseed@example.net";

    Intent intent = new Intent(MainActivity.this,
                               LinkActivity.class);

    intent.putExtra(
      Plaid.LINK_CONFIGURATION,
      new LinkConfiguration(
        clientName,
        environment,
        products,
        linkEventListener,
        language,
        countryCodes,
        webhook,
        userLegalName,
        userEmailAddress
    ));

    startActivityForResult(intent, LINK_REQUEST_CODE);
  }
}

Parameter reference

The table below describes the parameters to configure the PlaidLink SDK.

Parameter Description
clientName
String, required
Your company name which will be displayed for consent and after successfully linking an Item.
product
List, required
A list of Plaid product(s) you wish to use.

Valid products are:
  • Auth: PlaidProduct.AUTH
  • Transactions: PlaidProduct.TRANSACTIONS
  • Identity: PlaidProduct.IDENTITY
  • Income: PlaidProduct.INCOME
  • Assets: PlaidProduct.ASSETS
  • Investments: PlaidProduct.INVESTMENTS
  • Liabilities: PlaidProduct.LIABILITIES
environment
List, required
The Plaid API environment on which to create user accounts.

Available environments:
  • Sandbox: PlaidEnvironment.SANDBOX
  • Development: PlaidEnvironment.DEVELOPMENT
  • Production: PlaidEnvironment.PRODUCTION
language
String, optional
Specify a Plaid-supported language to localize Link. Accepted values must use the native Android Locale Language. English will be used by default.

Supported languages:
  • English: Locale.ENGLISH.language
  • French: Locale.FRENCH.language
  • Spanish Locale.SPANISH.language
countryCodes
List, optional
Specify an array of Plaid-supported country codes using the ISO-3166-1 alpha-2 country code standard. Accepted values must use the native Android Locale country.

Supported countries include:
  • Canada: Locale.CA.country
  • France: Locale.FR.country
  • Ireland: Locale.IE.country
  • Spain: Locale.ES.country
  • United Kingdom: Locale.GB.country
  • United States: Locale.US.country
  • more coming soon
webhook
String, optional
Specify a webhook to associate with an Item. Plaid fires a webhook when the Item requires updated credentials, when new data is available, or when Auth numbers have been successfully verified.
userLegalName
String, optional
Specify a userLegalName to enable all Auth features. Note that userEmailAddress must also be set.
userEmailAddress
String, optional
Specify a userEmailAddress to enable all Auth features. Note that userLegalName must also be set.
publicToken
String, optional
Specify a publicToken to launch Link in update mode for a particular Item. This will cause Link to open directly to the authentication step for that Item's institution.

Use the /item/public_token/create endpoint to generate a public_token for an Item.

The onActivityResult handler is called for the onSuccess, onCancelled, onExit and onException events.

The section on Implementation reference has a detailed overview of each event, its' corresponding response schema.

MainActivity

class MainActivity : AppCompatActivity() {

  companion object {
    const val LINK_REQUEST_CODE = 1
  }

  // configured in the previous step
  override fun onCreate(savedInstanceState: Bundle?) { ... }

  private val resultHandler = PlaidLinkActivityResultHandler(
    requestCode = LINK_REQUEST_CODE,
    onSuccess = { it: LinkConnection ->
      // handle onSuccess
    },
    onExit = { it: PlaidApiError ->
      // handle onExit
    },
    onCancelled = { it: LinkCancellation ->
      // handle onCancelled
    },
    onException = { it: Throwable ->
      // handle onError
    }
  )

  override fun onActivityResult(
    requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (resultHandler.onActivityResult(requestCode, resultCode, data)) {
      return
    } else {
      Log.i(TAG, "Not handled")
    }
  }
}


import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

  private static final int LINK_REQUEST_CODE = 1;

  // configured in the previous step
  @Override
  public void onCreate() { ... }

  @Override
  protected void onActivityResult(
    int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == LINK_REQUEST_CODE && data != null) {
      if (resultCode == Plaid.RESULT_SUCCESS) {
        // handle onSuccess
        // ...
      } else if (resultCode == Plaid.RESULT_EXIT) {
        // handle onExit
        // ...
      } else if (resultCode == Plaid.RESULT_CANCELLED) {
        // handle onCancelled
        // ...
      } else if (resultCode == Plaid.RESULT_EXCEPTION) {
        // handle onError
        // ...
      }
    } else {
      Log.i(this.getClass().getSimpleName(), "Not handled");
    }
  }
}

Exchanging Token flow

Exchange a Link public_token for an API access_token. Link hands off the public_token client-side via the onSuccess callback once a user has successfully created an Item. The public_token is ephemeral and expires after 30 minutes. A public_token becomes invalidated once it has been successfully exchanged for an access_token.

The response also includes an item_id that should be stored with the access_token. The item_id is used to identify an Item in a webhook. The item_id can also be retrieved by making an /item/get request.

See the full API requests and response details in the Exchange Token documentation.

Handling onSuccess

When a user successfully connects their institution with Plaid, and Item is created, and a public_token is returned which must be exchanged for an access_token.

The onSuccess handler returns a LinkConnection class that includes the public_token, and additional Link metadata in the form of a LinkConnectionMetadata class.

LinkConnection

data class LinkConnection(
  val publicToken: String,
  val linkConnectionMetadata: LinkConnectionMetadata
)

data class LinkConnectionMetadata(
  val accounts: List,
  val institutionId: String,
  val institutionName: String,
  val linkSessionId: String
)

data class LinkAccount(
  val accountId: String,
  val accountName: String?,
  val accountNumber: String?,
  val accountType: String?,
  val accountSubType: String?,
  val verificationStatus: String?
)

Parameter Description
linkSessionId
String
A unique identifier associated with a user's actions and events through the Link flow. Include this identifier when opening a support ticket for faster turnaround.
institutionName
String
The full institution name, such as 'Bank of America'
institutionId
String
The institution ID, such as ins_100000
accounts
[Object]
A list of objects with the following properties:
  • accountId: the id of the selected account
  • accountName: the name of the selected account
  • accountNumber: the last four digits of the selected account
  • accountType: the account type
  • accountSubType: the account subtype
  • verificationStatus: the Item's verficiation status. See below:
When all Auth features are enabled by initializing Link with the user parameters , the accounts object includes an Item's verificationStatus, with available status:
  • pending_automatic_verification: an Item is pending automated microdeposit verfication
  • pending_manual_verification: an Item is pending manual microdeposit verification
  • manually_verified: an Item was successfully manually verified
Checkout the Accounts section for more detailed documentation. To collect accounts data, you must enable the Select Account view via the Plaid Dashboard.
Handling onSuccess

private val handler = PlaidLinkActivityResultHandler (
  requestCode = LINK_REQUEST_CODE,
  ...
  onSuccess = {
    // Send public_token to your server, exchange for access_token
    String publicToken = it.publicToken

    val metadata = it.linkConnectionMetadata
    String accountId = metadata.accounts[0].accountId
    String accountName = metadata.accounts[0].accountName
    String accountNumber = metadata.accounts[0].accountNumber
    String accountType = metadata.accounts[0].accountType
    String accountSubType = metadata.accounts[0].accountSubType
    String institutionId = metadata.institutionId
    String institutionName = metadata.institutionName
  }}
)


@Override
protected void onActivityResult(
int requestCode, int resultCode, @Nullable Intent data) {
  // ...
  if (requestCode == LINK_REQUEST_CODE && data != null) {

    // Handle onSuccess
    if (resultCode == Plaid.RESULT_SUCCESS) {
      LinkConnection item = (LinkConnection)
        data.getSerializableExtra(Plaid.LINK_RESULT);

      if (item != null) {
        // Send public_token to your server,
        // exchange for access_token
        String publicToken = item.getPublicToken();

        LinkConnectionMetadata metadata =
          item.getLinkConnectionMetadata();
        String accountId =
          metadata.getAccounts().get(0).getAccountId();
        String accountName =
          metadata.getAccounts().get(0).getAccountName();
        String accountNumber =
          metadata.getAccounts().get(0).getAccountNumber();
        String accountType =
          metadata.getAccounts().get(0).getAccountType();
        String accountType =
          metadata.getAccounts().get(0).getAccountSubType();
        String institutionId = metadata.getInstitutionId();
        String institutionName = metadata.getInstitutionName();
      }
    }
  }
}

Handling onExit

The onExit handler is called when a user exits the Link flow prematurely. The PlaidApiError returned from onExit handler is meant to help you guide your users after they have exited Link. We recommend storing the error and metadata information server-side in a way that can be associated with the user. You’ll also need to include this and any other relevant info in Plaid Support requests for the user.

PlaidApiError

data class PlaidApiError(
  val errorType: String?,
  val errorCode: String?,
  val errorMessage: String?,
  val displayMessage: String?,
  val linkExitMetadata: LinkExitMetadata
)

data class LinkExitMetadata(
  val linkSessionId: String?,
  val institutionName: String?,
  val institutionId: String?,
  val requestId: String?,
  val status: String?
)

PlaidApiError schema

See the full Error documentation for all possible Plaid API errors.

Parameter Description
errorType
String
A broad categorization of the error.
errorCode
String
The particular error code. Each error_type has a specific set of error_codes.
errorMessage
String
A developer-friendly representation of the error code.
displayMessage
String
A user-friendly representation of the error code. null if the error is not related to user action. This may change over time and is not safe for programmatic use.
LinkExitMetadata
Parameter Description
linkSessionId
String
A unique identifier associated with a user's actions and events through the Link flow. Include this identifier when opening a support ticket for faster turnaround.
institutionName
String
The name of the user's selected institution, if available.
institutionId
String
The ID of the user's selected institution, if available.
requestId
String
The request ID for the last request made by Link. This can be shared with Plaid Support to expedite investigation.
status
String
An indication of the point at which the user exited the Link flow. See the Metadata status docs for all possible values.
Handling onExit

private val handler = PlaidLinkActivityResultHandler (
  requestCode = LINK_REQUEST_CODE,
  ...
  onExit = {
    String errorType = it.errorType
    String errorCode = it.errorCode
    String errorMessage = it.errorMessage
    String displayMessage = it.displayMessage
    String institutionId = it.linkExitMetadata.institutionId
    String institutionName = it.linkExitMetadata.institutionName
    String status = it.linkExitMetadata.status
  },
)


@Override
protected void onActivityResult(
int requestCode, int resultCode, @Nullable Intent data) {
  // ...
  if (requestCode == LINK_REQUEST_CODE && data != null) {

    // Handle onExit
    if (resultCode == resultCode == Plaid.RESULT_EXIT) {
      PlaidApiError error = (PlaidApiError)
        data.getSerializableExtra(Plaid.LINK_RESULT);

      if (error != null) {
        String errorType = error.getErrorType()
        String errorCode = error.getErrorCode()
        String errorMessage = error.getErrorMessage();
        String displayMessage = error.getDisplayMessage();

        LinkExitMetadata metadata = error.getLinkExitMetadata();
        String institutionId = metadata.getInstitutionId();
        String institutionName = metadata.getInstitutionName();
        String status = metadata.getStatus();
    }
  }
}

Handling onCancelled

We handle the Android back button specifically in the PlaidLink SDK, by firing the onCancelled event handler. This should be handled in conjunction with the onExit handler to capture all user action as the navigate or exit Link.

LinkCancellation

data class LinkCancellation(
  val institutionId: String?,
  val institutionName: String?,
  val linkSessionId: String,
  val status: String?
)

Parameter Description
institutionName
String
The name of the user's selected institution, if available.
institutionId
String
The ID of the user's selected institution, if available.
linkSessionId
String
A unique identifier associated with a user's actions and events through the Link flow. Include this identifier when opening a support ticket for faster turnaround.
status
String
An indication of the point at which the user exited the Link flow. See the Metadata status docs for all possible values.
Handling onCancelled

private val handler = PlaidLinkActivityResultHandler (
  requestCode = LINK_REQUEST_CODE,
  ...
  onCancelled = {
   String institutionId = it.institutionId
   String institutionName = it.institutionName
   String linkSessionId = it.linkSessionId
   String status = it.status
 },
)


@Override
protected void onActivityResult(
int requestCode, int resultCode, @Nullable Intent data) {
  // ...
  if (requestCode == LINK_REQUEST_CODE && data != null) {

    // Handle onCancelled
    if (resultCode == Plaid.RESULT_CANCELLED) {
      LinkCancellation cancellation = (LinkCancellation)
        data.getSerializableExtra(Plaid.LINK_RESULT);

      if (cancellation != null) {
        String insId = cancellation.getInstitutionId();
        String insName = cancellation.getInstitutionName();
        String linkSessionId = cancellation.getLinkSessionId();
        String status = cancellation.getStatus();
    }
  }
}

Handling onException

When a native Android error occurs somewhere in the PlaidLink SDK, we throw the onException handler event. This handler returns a native Throwable Error class.

Handling onException

private val handler = PlaidLinkActivityResultHandler (
  requestCode = LINK_REQUEST_CODE,
  ...
  onException = {
    String errorClass = it.javaClass.toString()
    String message = it.message
  }
)


@Override
protected void onActivityResult(
int requestCode, int resultCode, @Nullable Intent data) {
  // ...
  if (requestCode == LINK_REQUEST_CODE && data != null) {

    // Handle onExit
    if (resultCode == Plaid.RESULT_EXCEPTION) {
      Exception exception =
        (Exception) data.getSerializableExtra(Plaid.LINK_RESULT);
      if (exception != null) {
        String errorClass = exception.getClass().toString();
        String message = exception.getMessage();
      }
    }
  }
}

Handling onEvent

The onEvent callback is called at certain points in the Link flow. Unlike the handlers for onSuccess, onExit, onCancelled, and onException, the onEvent handler is initialized inside of the LinkConfiguration class, defined as the linkEventListener handler.

LinkEvent

data class LinkEvent(
  val eventName: String,
  val metadata: LinkEventMetadata
)

data class LinkEventMetadata(
  val institutionId: String?,
  val institutionName: String?,
  val institutionSearchQuery: String?,
  val linkSessionId: String,
  val mfaType: String?,
  val requestId: String,
  val timestamp: String,
  val viewName: LinkEventViewName?
)

enum class LinkEventViewName {
  CONNECTED,
  CREDENTIAL,
  ERROR,
  EXIT,
  LOADING,
  MFA,
  RECAPTCHA,
  SELECT_ACCOUNT,
  SELECT_INSTITUTION,
  UNKNOWN;
)

Event names
Event Description
ERROR A recoverable error occurred in the Link flow, see the error_code metadata.
EXIT The user has exited without completing the Link flow and the onExit callback is fired.
HANDOFF The user has completed the Link flow and the onSuccess callback is fired.
OPEN The user has opened Link.
OPEN_MY_PLAID The user has opened my.plaid.com. This event is only sent when Link is initialized with assets as a product
SEARCH_INSTITUTION The user has searched for an institution.
SELECT_INSTITUTION The user selected an institution.
SUBMIT_CREDENTIALS The user has submitted credentials.
SUBMIT_MFA The user has submitted MFA.
TRANSITION_VIEW The TRANSITION_VIEW event indicates that the user has moved from one view to the next.
Metadata Schema
Field Description
errorCode The error code that the user encountered. Emitted by: ERROR, EXIT.
errorMessage The error message that the user encountered. Emitted by: ERROR, EXIT.
errorType The error type](/docs/#errors) that the user encountered. Emitted by: ERROR, EXIT.
exitStatus The status key indicates the point at which the user exited the Link flow. Emitted by: EXIT.
institutionId The ID of the selected institution. Emitted by: all events.
institutionName The name of the selected institutioninstitutions. Emitted by: all events.
institutionSearchQuery The query used to search for institutions. Emitted by: SEARCH_INSTITUTION.
requestId The request ID for the last request made by Link. This can be shared with Plaid Support to expedite investigation. Emitted by: all events.
linkSessionId The link_session_id is a unique identifier for a single session of Link. It's always available and will stay constant throughout the flow. Emitted by: all events.
mfaType If set, the user has encountered one of the following MFA types: code, device, questions, selections. Emitted by: SUBMIT_MFA and TRANSITION_VIEW when view_name is MFA.
viewName The name of the view that is being transitioned to. Emitted by: TRANSITION_VIEW.
timestamp An ISO 8601 representation of when the event occurred. For example 2017-09-14T14:42:19.350Z. Emitted by: all events.
Metadata viewName
View Displayed when
CONNECTED The user has connected their account.
CREDENTIAL Asking the user for their account credentials.
ERROR An error has occurred.
EXIT Confirming if the user wishes to close Link.
LOADING Link is making a request to our servers.
MFA The user is asked by the institution for additional MFA authentication.
RECAPTCHA The user was presented with a Google reCAPTCHA to verify they are human.
SELECT_ACCOUNT We ask the user to choose an account.
SELECT_INSTITUTION We ask the user to choose their institution.
Handling onEvent

override fun onCreate(savedInstanceState: Bundle?) {

  val linkConfig = LinkConfiguration(
    // ...
    linkEventListener = LinkEventListener {
      String event = it.event
    },
  )

  val intent = Intent(this, LinkActivity::class.java)
  intent.putExtra(Plaid.LINK_CONFIGURATION, linkConfig)
}


@Override
protected void onCreate(Bundle savedInstanceState) {
  val linkEventListener = LinkEventListener {
    String event = linkEvent.getEvent();
  }

  intent.putExtra(
    Plaid.LINK_CONFIGURATION,
    new LinkConfiguration(
      // ...
      linkEventListener,
  ));
}

Updating Items

To open PlaidLink in update mode, generate a new public_token for a given access_token via the LinkConfiguration builder in the onCreate event handler.

MainActivity

intent.putExtra(
  Plaid.LINK_CONFIGURATION,
  LinkConfiguration(
    ...,
    publicToken = "<#GENERATED_PUBLIC_TOKEN#>"
  )
)


intent.putExtra(
  Plaid.LINK_CONFIGURATION,
  LinkConfiguration(
    ...,
    "<#GENERATED_PUBLIC_TOKEN#>",
    ...
  )
);

The preferred and recommended method to customize the Link Android SDK is to use customization feature in the dashboard, Plaid Link for Android will automatically use the values you provide there.

Dashboard Configuration

Troubleshooting

The order in terms of verbosity, from least to most is ERROR, WARN, INFO, DEBUG, VERBOSE. Verbose should never be compiled into an application except during development. Debug logs are compiled in but stripped at runtime. Error, warning and info logs are always kept.

LogLevel Value Description
NONE 0 Not available in the Android SDK.
VERBOSE 2 Show all log messages (the default).
DEBUG 3 Show debug log messages that are useful during development only, as well as the message levels lower in this list.
INFO 4 Show expected log messages for regular usage, as well as the message levels lower in this list.
WARN 5 Show possible issues that are not yet errors, as well as the message levels lower in this list.
ERROR 6 Show issues that have caused errors, as well as the message level lower in this list.
ASSERT 7 Show issues that the developer expects should never happen.
Troubleshooting

val plaidOptions =
  PlaidOptions.builder()
    .setLogging(
      if (BuildConfig.DEBUG) LogLevel.DEBUG else LogLevel.NONE)
    .build()

Plaid.create(this, plaidOptions)


PlaidOptions plaidOptions =
  new PlaidOptions.Builder()
    .logLevel(BuildConfig.DEBUG ? LogLevel.DEBUG : LogLevel.ASSERT)
    .build();

Plaid.create(this, plaidOptions);

Moving Forward

Migrating to production

Keep building your integration out in our Sandbox and Development API environments. When youʼre ready to go to Production, request access from the Dashboard. While you’re at it, be sure to also take a look at our Privacy Policy.

Getting help

Find answers to common integration and product questions at our Help Center. You can find all the code for this guide, including runnable sample applications, on GitHub.

Weʼre excited to see what you build!