Plaid logo
Docs
ALL DOCS

Auth

  • Introduction to Auth
  • Add Auth to your app
  • Move money with our partners
  • Add institution coverage
Plaid logo
Docs
Plaid.com
Get API keys

Same Day Micro-deposits

Learn how to authenticate your users with traditional, manually verified micro-deposits

Overview

Same Day Micro-deposits can be used to authenticate any bank account in the US, but especially for the ~2,000 institutions that don't support Instant Auth, Instant Match, or Automated Micro-deposit verification. Plaid will make two deposits that post within one business day (using Same Day ACH, which is roughly two days faster than the standard micro-deposit experience of two to three days). Users are instructed to manually verify the deposited amounts within one business day.

Same Day Micro-deposits Link flow

Not all Plaid Developer accounts are enabled for Automated Micro-deposits or Same Day Micro-deposits by default. To enable these features or check your status, contact your account manager or submit a product access Support ticket.

The Same Day Micro-deposit flow

A user connects their financial institution using the following connection flow:

  1. Starting on a page in your app, the user clicks an action that opens Plaid Link with the correct Auth configuration.
  2. Inside of Plaid Link, the user enters the micro-deposit initiation flow and provides their legal name, account and routing number.
  3. Upon successful authentication, Link closes with a public_token and a metadata account status of pending_manual_verification.
  4. Behind the scenes, Plaid sends two micro-deposits to the user's account that will post within one to two business days.
  5. After one to two days, the user is prompted to verify the two deposit amounts in their account, by opening Link with a generated link_token.
  6. Finally, Plaid will reverse the two micro-deposits to pull back the deposit amounts from the user's bank account.

When these steps are done, your user's Auth data is verified and ready to fetch.

Configure & Create a link_token

Create a link_token with the following parameters:

  • products array should include only auth as a product when using same-day manual micro-deposit verification. While in most cases additional products can be added to existing Plaid Items, Items created for same-day manual micro-deposit verification are an exception and cannot be used with any Plaid products other than Auth.
  • country_codes set to ['US'] – Micro-deposit verification is currently only available in the United States.
Select group for content switcher
1// Using Express
2const express = require('express');
3const app = express();
4app.use(express.json());
5
6const { Configuration, PlaidApi, PlaidEnvironments } = require('plaid');
7
8const configuration = new Configuration({
9 basePath: PlaidEnvironments[process.env.PLAID_ENV],
10 baseOptions: {
11 headers: {
12 'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
13 'PLAID-SECRET': process.env.PLAID_SECRET,
14 },
15 },
16});
17
18const client = new PlaidApi(configuration);
19
20app.post('/api/create_link_token', async function (request, response) {
21 // Get the client_user_id by searching for the current user
22 const user = await User.find(...);
23 const clientUserId = user.id;
24 const request = {
25 user: {
26 // This should correspond to a unique id for the current user.
27 client_user_id: clientUserId,
28 },
29 client_name: 'Plaid Test App',
30 products: ['auth'],
31 language: 'en',
32 webhook: 'https://webhook.example.com',
33 redirect_uri: 'https://domainname.com/oauth-page.html',
34 country_codes: ['US'],
35 };
36 try {
37 const createTokenResponse = await client.linkTokenCreate(request);
38 response.json(createTokenResponse.data);
39 } catch (error) {
40 // handle error
41 }
42});

Initialize Link with a link_token

After creating a link_token for the auth product, use it to initialize Plaid Link.

When the user successfully inputs their account and routing numbers, the onSuccess() callback function will return a public_token, with verification_status equal to 'pending_manual_verification'.

1const linkHandler = Plaid.create({
2 // Fetch a link_token configured for 'auth' from your app server
3 token: (await $.post('/create_link_token')).link_token,
4 onSuccess: (public_token, metadata) => {
5 // Send the public_token and connected accounts to your app server
6 $.post('/exchange_public_token', {
7 publicToken: public_token,
8 accounts: metadata.accounts,
9 });
10
11 metadata = {
12 ...,
13 link_session_id: String,
14 institution: {
15 name: null, // name is always null for same day micro-deposits
16 institution_id: null // institution_id is always null for same day micro-deposits
17 },
18 accounts: [{
19 id: 'vzeNDwK7KQIm4yEog683uElbp9GRLEFXGK98D',
20 mask: '1234',
21 name: null,
22 type: 'depository',
23 subtype: 'checking' | 'savings',
24 verification_status: 'pending_manual_verification'
25 }]
26 }
27 },
28 // ...
29});
30
31// Open Link on user-action
32linkHandler.open();
Display a "pending" status in your app

Because Same Day verification usually takes one business day to complete, we recommend displaying a UI in your app that communicates to a user that verification is currently pending.

You can use the verification_status key returned in the onSuccess metadata.accounts object once Plaid Link closes successfully.

1verification_status: 'pending_manual_verification';

You can also fetch the verification_status for an Item's account via the Plaid API, to obtain the latest account status.

User entry points in Link

The following table describes the primary entry points into the manual micro-deposit flow:

ExitErrorInstitution SearchInstitution SearchInstitution Select
When user clicks X action buttonWhen user encounters any errorWhen no results are foundWhen user scrolls to end of resultsWhen institution health is poor

In addition to the entry points above, you can optionally configure Same Day Micro-deposit flow to be available as an option on the main Auth screen, even if Instant Match or Instant Auth is available. Enabling Same Day Micro-deposits in this way can result in typical conversion increases of up to 5 percentage points. For more information on enabling this setting, see Flexible Auth.

Exchange the public token

In your own backend server, call the /item/public_token/exchange endpoint with the Link public_token received in the onSuccess callback to obtain an access_token. Persist the returned access_token, account_id, and item_id in your database in relation to the user.

Note that micro-deposits will only be delivered to the ACH network in the Production environment, and not in Development. To test your integration outside of Production, see Testing same day micro-deposits in Sandbox.

Select group for content switcher
1// publicToken and accountID are sent from your app to your backend-server
2const accountID = 'vzeNDwK7KQIm4yEog683uElbp9GRLEFXGK98D';
3const publicToken = 'public-sandbox-b0e2c4ee-a763-4df5-bfe9-46a46bce993d';
4
5// Obtain an access_token from the Link public_token
6const response = await client
7 .itemPublicTokenExchange({
8 public_token: publicToken,
9 })
10 .catch((err) => {
11 // handle error
12 });
13const accessToken = response.access_token;
1{
2 "access_token": "access-sandbox-5cd6e1b1-1b5b-459d-9284-366e2da89755",
3 "item_id": "M5eVJqLnv3tbzdngLDp9FL5OlDNxlNhlE55op",
4 "request_id": "m8MDnv9okwxFNBV"
5}

Check the account verification status (optional)

In some cases you may want to implement logic in your app to display the verification_status of an Item that is pending manual verification. The /accounts/get API endpoint allows you to query this information.

Select group for content switcher
1// Fetch the accountID and accessToken from your database
2const accountID = 'vzeNDwK7KQIm4yEog683uElbp9GRLEFXGK98D';
3const accessToken = 'access-sandbox-5cd6e1b1-1b5b-459d-9284-366e2da89755';
4const request: AccountsGetRequest = {
5 access_token: accessToken,
6};
7const response = await client.accountsGet(request).catch((err) => {
8 // handle error
9});
10const account = response.accounts.find((a) => a.account_id === accountID);
11const verificationStatus = account.verification_status;
1{
2 "accounts": [
3 {
4 "account_id": "vzeNDwK7KQIm4yEog683uElbp9GRLEFXGK98D",
5 "balances": { Object },
6 "mask": "0000",
7 "name": null,
8 "official_name": null,
9 "type": "depository"
10 "subtype": "checking" | "savings",
11 "verification_status":
12 "pending_manual_verification" |
13 "manually_verified" |
14 "verification_expired",
15 },
16 ...
17 ],
18 "item": { Object },
19 "request_id": String
20}

Prompt user to verify micro-deposits in Link

After one to two business days, the two micro-deposits sent to the user's account are expected to have posted. To securely verify a Same Day Micro-deposits account, your user needs to come back into Link to verify the two amounts manually.

To optimze conversion, we strongly recommend sending your user a notification (e.g. email, SMS, push notification) prompting them to come back into your app and verify the two posted micro-deposit amounts.

Verification of Same Day Micro-deposits is performed in two steps:

  1. In your backend server, create a new link_token from the associated access_token for the given user.
  2. Pass the generated link_token into your client-side app, using the token parameter in the Link configuration. This will automatically trigger the micro-deposit verification flow in Link.
Create a new link_token from a persistent access_token

Generate a link_token for verifying micro-deposits by passing the user's associated access_token to the /link/token/create API endpoint. Note that the products field should not be set because the micro-deposits verification flow does not change the products associated with the given access_token.

Select group for content switcher
1// Using Express
2const express = require('express');
3const app = express();
4app.use(express.json());
5
6const { Configuration, PlaidApi, PlaidEnvironments } = require('plaid');
7
8const configuration = new Configuration({
9 basePath: PlaidEnvironments[process.env.PLAID_ENV],
10 baseOptions: {
11 headers: {
12 'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
13 'PLAID-SECRET': process.env.PLAID_SECRET,
14 'Plaid-Version': '2020-09-14',
15 },
16 },
17});
18
19const client = new PlaidApi(configuration);
20
21app.post('/api/create_link_token', async function (request, response) {
22 // Get the client_user_id by searching for the current user
23 const user = await User.find(...);
24 const clientUserId = user.id;
25 const request = {
26 user: {
27 client_user_id: clientUserId,
28 },
29 client_name: 'Plaid Test App',
30 language: 'en',
31 webhook: 'https://webhook.sample.com',
32 country_codes: [CountryCode.Us],
33 access_token: 'ENTER_YOUR_ACCESS_TOKEN',
34 };
35 try {
36 const createTokenResponse = await client.linkTokenCreate(request);
37 response.json(createTokenResponse.data);
38 } catch (error) {
39 // handle error
40 }
41});
Initialize Link with the generated link_token

In your client-side app, pass the generated link_token into the Link token parameter. Link will automatically detect that Same Day verification is required for the Item and will open directly into the verification flow (see the image above).

In Link, the user will be prompted to log in to their personal banking portal to confirm the two deposit amounts. Upon successful entry of the two amounts, the onSuccess callback will be fired, with an updated verification_status: 'manually_verified'.

There is no time limit for the user to verify the deposits, and the deposits can be entered in any order. A user has three attempts to enter their deposit amounts correctly, after which the Item will be permanently locked for security reasons. See INCORRECT_DEPOSIT_AMOUNTS and PRODUCT_NOT_READY for errors that may occur during the micro-deposit initiation and verification flow.

1const linkHandler = Plaid.create({
2 token: await fetchLinkTokenForMicrodepositsVerification(),
3 onSuccess: (public_token, metadata) => {
4 metadata = {
5 accounts: [{
6 ...,
7 verification_status: 'manually_verified',
8 }],
9 };
10 },
11 // ...
12});
13
14// Open Link to verify micro-deposit amounts
15linkHandler.open();

An Item's access_token does not change when verifying micro-deposits, so there is no need to repeat the exchange token process.

Fetch Auth data

Finally, we can retrieve Auth data once the user has manually verified their account through Same Day Micro-deposits:

Select group for content switcher
1const accessToken = 'access-sandbox-5cd6e1b1-1b5b-459d-9284-366e2da89755';
2
3// Instantly fetch Auth numbers
4const request: AuthGetRequest = {
5 access_token: accessToken,
6};
7const response = await client.authGet(request).catch((err) => {
8 // handle error
9});
10const numbers = response.numbers;
1{
2 "numbers": {
3 "ach": [
4 {
5 "account_id": "vzeNDwK7KQIm4yEog683uElbp9GRLEFXGK98D",
6 "account": "9900009606",
7 "routing": "011401533",
8 "wire_routing": "021000021"
9 }
10 ],
11 "eft": [],
12 "international": [],
13 "bacs": []
14 },
15 "accounts": [
16 {
17 "account_id": "vzeNDwK7KQIm4yEog683uElbp9GRLEFXGK98D",
18 "balances": { Object },
19 "mask": "0000",
20 "name": null,
21 "official_name": null,
22 "verification_status": "manually_verified",
23 "subtype": "checking" | "savings",
24 "type": "depository"
25 }
26 ],
27 "item": { Object },
28 "request_id": "m8MDnv9okwxFNBV"
29}

Check out the /auth/get API reference documentation to see the full Auth request and response schema.

Micro-deposit transaction description

When the micro-deposits post to your end user's bank account, the transaction description will be written with the format:

1<clientName> ACCTVERIFY

Plaid will reverse the microdeposits with one or more debit, but will not exceed the amount of the corresponding deposits — the transaction description will be written with the format:

1<clientName> ACCTVERIFY

The <clientName> is defined by the value of the client_name parameter that was used to create the link_token that initialized Link.

Business or corporate accounts

Users with business or corporate accounts that have ACH debit blocks enabled on their account may need to authorize Plaid's Company / Tax ID, 1460820571, to avoid any issues with linking their accounts.

Flexible Auth

Integrate the Flexible Auth flow

View guide

Testing in Sandbox

Learn how to test each Auth flow in the Sandbox

View guide

Micro-deposit events

Learn how to use Bank Transfers (beta) webhooks to receive micro-deposit status updates

View guide
Was this helpful?
Developer community
Github logo
StackOverflow logo
Twitter logo