Bond Studio

The Bond Developer Hub

Welcome to the Bond Studio Developer Hub.

Get up and running fast with documentation, guides, and support.

Let's get started!

Get Started    API Reference

Linking external accounts

Introduction

The accounts API allows you to link a customer's Bond card to their verified external bank account. The customer can then transfer funds back and forth between their card account and the linked external account. Once the link is established, we use the linked_account_id identifier to represent the customer's external account.

For examples of how to use the SDK, see SDK Documentation.

Linking process overview

The tokens employed and their use is shown in the table below.

Token

Origin and use

link_token

Temporary token returned by Plaid on initial request to link a bank account.

public_token

Returned by Plaid after customer supplies their bank details.

access_token

Replaced for the public_token by Plaid when requested by Bond,

Bond uses Plaid Link to enable the customer to provide their bank account information.

When a customer requests to link their card to an external account, Plaid returns a temporary link_token that allows them to log in to Plaid Link and provide their bank account details.

Once Plaid receives the customer's bank account details, it passes a temporary public_token back to Bond, along with an account_id identifier. This is Plaid's identifier for the customer's external account. Within Bond Studio, this identifier is stored as external_account_id.

Bond requests a permanent access_token from Plaid in exchange for the temporary public_token. This access_token uniquely represents the customer's login for their bank account.

The Bond endpoints that make requests to the Plaid APIs require the access_token to identify the customer's linked external account within Plaid.

Account verification

There are several mechanisms for verifying a customer's bank account. To achieve instant account verification and linkage, this process is done using Plaid Link. Plaid also provides manual account verification via micro-deposits, as well as the ability to link to an unverifiable account. Plaid offers the following options to link external accounts, as shown in the table below.

Account Linking method

Description

Instant auth

The default Auth flow. Doesn't require extra configuration steps if Auth is already configured in your app. Supports more than 3,800 financial institutions with credential-based login.

Instant match

When using Instant Match, Plaid Link prompts your user to enter their account number and routing number. Plaid then verifies the last four digits of the user-provided account number against the account mask retrieved from the financial institution. Instant match is automatically provided at supported institutions as a fall-back method when Instant Auth is not available.

Same-day micro-deposits

Used for institutions that don't support Instant Auth, Instant Match, or Automated Micro-deposit verification. Plaid makes two deposits that post within one business day (using Same Day ACH). Users are instructed to manually verify the deposited amounts within one business day.

Automated micro-deposits

Plaid makes a single micro-deposit and then automatically verifies it within one to two business days.

Unverifiable

Used in a case where a user wants to send a transfer to an external account that is not their own.

This video provides a high-level overview of the first four Plaid Auth options listed above—Plaid authorization flows.

Automatic verification

Plaid's Instant Auth and Instant Match processes allow a customer to instantly verify their external account using Plaid Link:

  • Instant Auth—The customer can search for their banking institution and provide their login credentials.
  • Instant Match—The customer manually enters the account numbers.

Installing the SDK

This process is done by using by Plaid's Javascript-based, Link web SDK. To install the SDK, follow the procedure in this link—Plaid Link JS web SDK.

Once installed, the Plaid Link SDK provides the Plaid.create Link object. This is used to load Plaid's bank "Institution Select" window. This handler requires a link_token in order to operate, as shown below.

const handler = Plaid.create({
  token: 'GENERATED_LINK_TOKEN',
  onSuccess: (public_token, metadata) => {},
  onLoad: () => {},
  onExit: (err, metadata) => {},
  onEvent: (eventName, metadata) => {},
  receivedRedirectUri: null,
});

Retrieving the link_token

To retrieve the link_token, use the GET /accounts/{account_id}/external_accounts/plaid operation with no further parameters as shown in the example below. The account_id path parameter is the customer's Bond card account ID.

curl --request POST \
     --url https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid \
     --header 'Accept: application/json' \
     --header 'Authorization: YOUR-AUTHORIZATION' \
     --header 'Content-Type: application/json' \
     --header 'Identity: YOUR-IDENTITY'
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Accept"] = 'application/json'
request["Content-Type"] = 'application/json'
request["Identity"] = 'YOUR-IDENTITY'
request["Authorization"] = 'YOUR-AUTHORIZATION'

response = http.request(request)
puts response.read_body
const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Identity: 'YOUR-IDENTITY',
    Authorization: 'YOUR-AUTHORIZATION'
  }
};

fetch('https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
import requests

url = "https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid"

headers = {
    "Accept": "application/json",
    "Content-Type": "application/json",
    "Identity": "YOUR-IDENTITY",
    "Authorization": "YOUR-AUTHORIZATION"
}

response = requests.request("POST", url, headers=headers)

print(response.text)
var client = new RestClient("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid");
var request = new RestRequest(Method.POST);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Identity", "YOUR-IDENTITY");
request.AddHeader("Authorization", "YOUR-AUTHORIZATION");
IRestResponse response = client.Execute(request);
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid")
  .post(null)
  .addHeader("Accept", "application/json")
  .addHeader("Content-Type", "application/json")
  .addHeader("Identity", "YOUR-IDENTITY")
  .addHeader("Authorization", "YOUR-AUTHORIZATION")
  .build();

Response response = client.newCall(request).execute();

For a complete specification and interactive examples, see Generate Plaid link token in the Bond API Reference.

This request establishes the link between Bond's card account and the customer's external account. A successful request returns the following:

  • linked_account_id—This UUID is Bond's identifier for the customer's external bank account ID.
  • link_token—A temporary token needed by Plaid's SDK. Bond's backend retrieves this from Plaid's /link/token/create API. It allows the customer to log in to Plaid Link to add their bank account credentials.

An example of a successful response is shown below.

{
    "linked_account_id": "1a130d45-3dc3-4c58-b0d8-9784aae0d009",
    "status": "inactive",
    "verification_status": null,
    "link_token": "link-sandbox-09fa148c-497a-4a22-87c9-581a7dea46de",
    "expiration": "2021-01-27T23:29:06Z"
}

With a successful response the Plaid Link process can continue.

Selecting the institution

To open Plaid's Institution Select window, execute handler.open(). The customer can now search for and select their banking institution. They provide their login credentials and then select the bank account that they want to link to their card. Alternatively, their institute may only allow them to instantly match their account based on manually inputted account numbers. The Link SDK is configured so that the customer can select only one account at their banking institution.

The Link object returns a public_token and metadata when the onSuccess() callback is triggered on successful link initialization.

The metadata includes:

  • The institution name
  • The Plaid account_id associated with the customer's selected bank account. Within Bond Studio, this identifier is stored as external_account_id.
  • The link verification_status. This is null during Instant Auth and Instant Match, but is required in the case of manual verification.

The account_id is listed in metadata.accounts[].id. The example below shows the metadata in the response. You need to save the metadata as it is required in the next API call.

{
  institution: {
    name: 'Wells Fargo',
    institution_id: 'ins_4'
  },
  accounts: [
    {
      id: 'ygPnJweommTWNr9doD6ZfGR6GGVQy7fyREmWy',
      name: 'Plaid Checking',
      mask: '0000',
      type: 'depository',
      subtype: 'checking',
      verification_status: ''
    },
    {
      id: '9ebEyJAl33FRrZNLBG8ECxD9xxpwWnuRNZ1V4',
      name: 'Plaid Saving',
      mask: '1111',
      type: 'depository',
      subtype: 'savings'
    }
    ...
  ],
  link_session_id: '79e772be-547d-4c9c-8b76-4ac4ed4c441a'
}

Finishing the linking process

To finish the linking process, exchange the temporary public_token for the account's permanent access_token by using the POST /accounts/{account_id}/external_accounts/plaid operation with the body parameters as shown below.

Parameter

Type

Description

public_token
required

String

Temporary token sent by Plaid to the client application.

linked_account_id
required

String

Bond's account UUID (36 characters) for the linked account.

external_account_id
required

String

Plaid's account ID for the external account.

status
required

String

Verification status of the external Plaid account.
Possible values:

  • `instantly_verified` (Instant Auth)
  • `pending_automatic_verification` (Automated Micro-Deposits)
  • `pending_manual_verification` (Same-Day Micro-Deposits)

bank_name

String

Freefor, alphanumeric name of the external bank account being linked, for example Casino Royale

Note:

  • external_account_id—corresponds to Plaid's metadata.accounts[].id.
  • status from the verification_status in the metadata returned, as shown above. For Instant Auth and Instant Match, set the value of status to instantly_verified as the verification_status is null. For manual verification, verification_status cannot be null.
  • bank_name (optional)—from the institution name in the metadata, if available.

On the server-side, Bond sends a request to Plaid's /item/public_token/exchange endpoint.

For a complete specification and interactive examples, see Exchanging Plaid tokens in the Bond API Reference.

The following example shows a request for a permanent token belonging to an external account that has been verified by Instant Auth.

curl --request POST \
     --url https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid \
     --header 'Accept: application/json' \
     --header 'Authorization: YOUR-AUTHORIZATION' \
     --header 'Content-Type: application/json' \
     --header 'Identity: YOUR-IDENTITY' \
     --data '
{
     "public_token": "public-sandbox-98de91d9-7794-49e2-a397-279734e597ae",
     "linked_account_id": "f897b0ac-f5aa-8402-ae1d-fd6b32f0ade9",
     "external_account_id": "1gxb4pgQ8VcV7xanAxp1sxAAjNERA4iQ6w1Vm",
     "status": "instantly_verified",
     "bank_name": "Chase Bank"
}
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Accept"] = 'application/json'
request["Content-Type"] = 'application/json'
request["Identity"] = 'YOUR-IDENTITY'
request["Authorization"] = 'YOUR-AUTHORIZATION'
request.body = "{\"public_token\":\"public-sandbox-98de91d9-7794-49e2-a397-279734e597ae\",\"linked_account_id\":\"f897b0ac-f5aa-8402-ae1d-fd6b32f0ade9\",\"external_account_id\":\"1gxb4pgQ8VcV7xanAxp1sxAAjNERA4iQ6w1Vm\",\"status\":\"instantly_verified\",\"bank_name\":\"Chase Bank\"}"

response = http.request(request)
puts response.read_body
const options = {
  method: 'POST',
  headers: {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    Identity: 'YOUR-IDENTITY',
    Authorization: 'YOUR-AUTHORIZATION'
  },
  body: JSON.stringify({
    public_token: 'public-sandbox-98de91d9-7794-49e2-a397-279734e597ae',
    linked_account_id: 'f897b0ac-f5aa-8402-ae1d-fd6b32f0ade9',
    external_account_id: '1gxb4pgQ8VcV7xanAxp1sxAAjNERA4iQ6w1Vm',
    status: 'instantly_verified',
    bank_name: 'Chase Bank'
  })
};

fetch('https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
import requests

url = "https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid"

payload = {
    "public_token": "public-sandbox-98de91d9-7794-49e2-a397-279734e597ae",
    "linked_account_id": "f897b0ac-f5aa-8402-ae1d-fd6b32f0ade9",
    "external_account_id": "1gxb4pgQ8VcV7xanAxp1sxAAjNERA4iQ6w1Vm",
    "status": "instantly_verified",
    "bank_name": "Chase Bank"
}
headers = {
    "Accept": "application/json",
    "Content-Type": "application/json",
    "Identity": "YOUR-IDENTITY",
    "Authorization": "YOUR-AUTHORIZATION"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)
var client = new RestClient("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid");
var request = new RestRequest(Method.POST);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Identity", "YOUR-IDENTITY");
request.AddHeader("Authorization", "YOUR-AUTHORIZATION");
request.AddParameter("application/json", "{\"public_token\":\"public-sandbox-98de91d9-7794-49e2-a397-279734e597ae\",\"linked_account_id\":\"f897b0ac-f5aa-8402-ae1d-fd6b32f0ade9\",\"external_account_id\":\"1gxb4pgQ8VcV7xanAxp1sxAAjNERA4iQ6w1Vm\",\"status\":\"instantly_verified\",\"bank_name\":\"Chase Bank\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"public_token\":\"public-sandbox-98de91d9-7794-49e2-a397-279734e597ae\",\"linked_account_id\":\"f897b0ac-f5aa-8402-ae1d-fd6b32f0ade9\",\"external_account_id\":\"1gxb4pgQ8VcV7xanAxp1sxAAjNERA4iQ6w1Vm\",\"status\":\"instantly_verified\",\"bank_name\":\"Chase Bank\"}");
Request request = new Request.Builder()
  .url("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid")
  .post(body)
  .addHeader("Accept", "application/json")
  .addHeader("Content-Type", "application/json")
  .addHeader("Identity", "YOUR-IDENTITY")
  .addHeader("Authorization", "YOUR-AUTHORIZATION")
  .build();

Response response = client.newCall(request).execute();

A successful response returns a permanent access_token which uniquely represents the customer's login for their bank account.

{
    "access_token": "access-sandbox-035d67aa-5d6b-4014-98af-e09b7335ea31",
    "status": "active",
    "verification_status": "instantly_verified",
    "account_type": "checking",
    "account_category": "depository"
}

Bond-Plaid link SDK shows an example of installing the Plaid Link SDK and using it with the Bond backend APIs.

The customer's external bank account has now been successfully linked and can be used, for example, for making ACH transfers to and from their Bond card account.

Manual verification

Plaid Link offers two types of manual verifications:

  • Same-day micro-deposits
  • Automated micro-deposits

In both cases, the customer does not enter their bank login credentials in Plaid Link. Instead, they manually input their bank account information. Trial micro-deposits are used to verify the account.
The following links provide further details.

📘

Plaid manual verification

Automated
Same-day

Both manual verification flows are initiated using the Plaid Link SDK. Both require a link_token to facilitate login to Plaid Link and you must swap the temporary token for a permanent access_token.

When initiating an Automated micro-deposit flow, the value of verification_status in the response is pending_automatic_verification. When the two trial micro-deposits are successfully deposited to the customer's external bank account, Plaid sends a webhook notifying Bond that the account was automatically_verified. If the micro-deposits are not successful, Plaid notifies Bond that the verification_expired, at which point the customer must attempt the process again. This process can take 1-2 business days.

For Same-day micro-deposits, the verification_status is returned as pending_manual_verification. In this case, the customer must log in to their external bank account and obtain the two trial micro-deposits, which will post within 1 business day. After posting, the customer needs to reinitiate the Plaid Link flow. The Plaid Link SDK then returns a verification_status value of manually_verified or verification_failed, depending on the success or failure of the micro-deposit verification.

While the micro-deposit flows are pending verification, the Bond linked account remains inactive and can't be used for making ACH transfers. Once verified, the external account becomes active. See [Plaid auth sandbox testing}(https://plaid.com/docs/auth/coverage/testing/) which describes how to test these flows using the Plain Link SDK in the sandbox.

Reinitializing a link

After a customer has successfully completed the Plaid Link flow, there are two scenarios where they may need to reinitiate the Plaid Link SDK:

  • To verify Same-day micro-deposits
  • To update their external bank login credentials

Since the external account was already successfully linked and an access_token has already been granted, we only need to reinitialize the Plaid Link SDK through the generation of a new link_token. For example, the customer may log back into the developer's app and be directed to initiate the process to verify micro-deposits by reinitializing and running the Plaid Link SDK.

To achieve this, use the Patch /accounts/{account_id}/external_accounts/plaid operation and provide the following body parameter.

Parameter

Type

Description

linked_account_id
required

String

Bond's account UUID (36 characters) for the linked account.

An example of a request to re-initialize a link is shown below.

curl --request PATCH \
     --url https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid \
     --header 'Authorization: YOUR-AUTHORIZATION' \
     --header 'Content-Type: application/json' \
     --header 'Identity: YOUR-IDENTITY' \
     --data '
{
     "linked_account_id": "f897b0ac-f5aa-4802-ae1d-fd6b32f0ade9"
}
const options = {
  method: 'PATCH',
  headers: {
    'Content-Type': 'application/json',
    Identity: 'YOUR-IDENTITY',
    Authorization: 'YOUR-AUTHORIZATION'
  },
  body: JSON.stringify({linked_account_id: 'f897b0ac-f5aa-4802-ae1d-fd6b32f0ade9'})
};

fetch('https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
import requests

url = "https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid"

payload = {"linked_account_id": "f897b0ac-f5aa-4802-ae1d-fd6b32f0ade9"}
headers = {
    "Content-Type": "application/json",
    "Identity": "YOUR-IDENTITY",
    "Authorization": "YOUR-AUTHORIZATION"
}

response = requests.request("PATCH", url, json=payload, headers=headers)

print(response.text)
var client = new RestClient("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Identity", "YOUR-IDENTITY");
request.AddHeader("Authorization", "YOUR-AUTHORIZATION");
request.AddParameter("application/json", "{\"linked_account_id\":\"f897b0ac-f5aa-4802-ae1d-fd6b32f0ade9\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"linked_account_id\":\"f897b0ac-f5aa-4802-ae1d-fd6b32f0ade9\"}");
Request request = new Request.Builder()
  .url("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/external_accounts/plaid")
  .patch(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Identity", "YOUR-IDENTITY")
  .addHeader("Authorization", "YOUR-AUTHORIZATION")
  .build();

Response response = client.newCall(request).execute();

A successful request returns the new link token as shown in the example below.

{
    "status": "inactive",
    "verification_status": "instantly_verified",
    "link_token": "link-sandbox-0c77a4df-c9c3-4e54-a0a0-5d2c053ae9c0",
    "expiration": "2021-01-27T23:29:06Z"
}

Bond-Plaid link SDK shows an example of installing the Plaid Link SDK and using it with the Bond backend APIs.

Linking an unverifiable account

When your customer wants to transfer funds to an external account that's not their own, obviously you can't very the external account. For example, a customer may want to transfer funds from their card to a third party.

To transfer funds to an unverifiable account, use the POST /accounts/account_id/migrate_account/plaid operation and provide the body parameters as shown in the table below.

This request retrieves an access_token to authorize a fund transfer from a customer's card account to an external account owned by a third party.

Parameter

Type

Description

account_number
required

String

External bank account number.

routing_number
required

String

Bank routing number.

account_type
required

String

Bank account type.
Possible values:

  • `checking`
  • `savings`

bank_name

String

Freeform, alphanumeric name of the external bank account being linked, for example Casino Royale

An example of a request to transfer funds to an external account is shown below.

curl --request POST \
     --url https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/migrate_account/plaid \
     --header 'Authorization: YOUR-AUTHORIZATION' \
     --header 'Content-Type: application/json' \
     --header 'Identity: YOUR-IDENTITY' \
     --data '
{
     "account_type": "savings",
     "account_number": "1111222233335897",
     "routing_number": "021000770",
     "bank_name": "Casino Royale"
}
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/migrate_account/plaid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request["Identity"] = 'YOUR-IDENTITY'
request["Authorization"] = 'YOUR-AUTHORIZATION'
request.body = "{\"account_type\":\"savings\",\"account_number\":\"1111222233335897\",\"routing_number\":\"021000770\",\"bank_name\":\"Casino Royale\"}"

response = http.request(request)
puts response.read_body
const options = {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Identity: 'YOUR-IDENTITY',
    Authorization: 'YOUR-AUTHORIZATION'
  },
  body: JSON.stringify({
    account_type: 'savings',
    account_number: '1111222233335897',
    routing_number: '021000770',
    bank_name: 'Casino Royale'
  })
};

fetch('https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/migrate_account/plaid', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
import requests

url = "https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/migrate_account/plaid"

payload = {
    "account_type": "savings",
    "account_number": "1111222233335897",
    "routing_number": "021000770",
    "bank_name": "Casino Royale"
}
headers = {
    "Content-Type": "application/json",
    "Identity": "YOUR-IDENTITY",
    "Authorization": "YOUR-AUTHORIZATION"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)
var client = new RestClient("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/migrate_account/plaid");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Identity", "YOUR-IDENTITY");
request.AddHeader("Authorization", "YOUR-AUTHORIZATION");
request.AddParameter("application/json", "{\"account_type\":\"savings\",\"account_number\":\"1111222233335897\",\"routing_number\":\"021000770\",\"bank_name\":\"Casino Royale\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"account_type\":\"savings\",\"account_number\":\"1111222233335897\",\"routing_number\":\"021000770\",\"bank_name\":\"Casino Royale\"}");
Request request = new Request.Builder()
  .url("https://sandbox.bond.tech/api/v0/accounts/9dc86a8a-4c12-4107-84a8-e7cf6a76586f/migrate_account/plaid")
  .post(body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Identity", "YOUR-IDENTITY")
  .addHeader("Authorization", "YOUR-AUTHORIZATION")
  .build();

Response response = client.newCall(request).execute();

A successful request returns an access_token and linked_account_id to represent the link between the customer's account and the external account, as shown below.

{
    "linked_account_id": "1a130d45-3dc3-4c58-b0d8-9784aae0d009",
    "access_token": "access-sandbox-035d67aa-5d6b-4014-98af-e09b7335ea31",
    "status": "active",
    "verification_status": "unverifiable",
    "account_type": "checking",
    "account_category": "depository"
}

For a complete specification and interactive examples, see Transferring funds to an unverifiable account in the Bond API Reference.

Updated 2 days ago



Linking external accounts


Suggested Edits are limited on API Reference Pages

You can only suggest edits to Markdown body content, but not to the API spec.