Sandbox endpoints

Use the /sandbox/public_token/create endpoint to create a valid public_token for an arbitrary institution ID, initial products, and test credentials. The created public_token maps to a new Sandbox Item. You can then call /item/public_token/exchange to exchange the public_token for an access_token and perform all API actions. /sandbox/public_token/create can also be used with the user_custom test username to generate a test account with custom data, or with Plaid's pre-populated Sandbox test accounts.

const publicTokenRequest: SandboxPublicTokenCreateRequest = {
  institution_id: institutionID,
  initial_products: initialProducts,
};
try {
  const publicTokenResponse = await client.sandboxPublicTokenCreate(
    publicTokenRequest,
  );
  const publicToken = publicTokenResponse.data.public_token;
  // The generated public_token can now be exchanged
  // for an access_token
  const exchangeRequest: ItemPublicTokenExchangeRequest = {
    public_token: publicToken,
  };
  const exchangeTokenResponse = await client.itemPublicTokenExchange(
    exchangeRequest,
  );
  const accessToken = exchangeTokenResponse.data.access_token;
} catch (error) {
  // handle error
}

Use the /sandbox/processor_token/create endpoint to create a valid processor_token for an arbitrary institution ID and test credentials. The created processor_token corresponds to a new Sandbox Item. You can then use this processor_token with the /processor/ API endpoints in Sandbox. You can also use /sandbox/processor_token/create with the user_custom test username to generate a test account with custom data.

const request: SandboxProcessorTokenCreateRequest = {
  institution_id: institutionID,
};
try {
  const response = await plaidClient.sandboxProcessorTokenCreate(request);
  const processorToken = response.data.processor_token;
} catch (error) {
  // handle error
}

/sandbox/item/reset_login/ forces an Item into an ITEM_LOGIN_REQUIRED state in order to simulate an Item whose login is no longer valid. This makes it easy to test Link's update mode flow in the Sandbox environment. After calling /sandbox/item/reset_login, You can then use Plaid Link update mode to restore the Item to a good state. An ITEM_LOGIN_REQUIRED webhook will also be fired after a call to this endpoint, if one is associated with the Item.
In the Sandbox, Items will transition to an ITEM_LOGIN_REQUIRED error state automatically after 30 days, even if this endpoint is not called.

const request: SandboxItemResetLoginRequest = {
  access_token: accessToken,
};
try {
  const response = await plaidClient.sandboxItemResetLogin(request);
  // create a public_token for the Item and use it to
  // initialize Link in update mode.
  const pt_request: itemPublicTokenCreateRequest = {
    access_token: accessToken,
  };
  const pt_response = await plaidClient.itemCreatePublicToken(pt_request);
  const publicToken = pt_response.public_token;
} catch (error) {
  // handle error
}

/sandbox/user/reset_login/ functions the same as /sandbox/item/reset_login, but will modify Items related to a User. This endpoint forces each Item into an ITEM_LOGIN_REQUIRED state in order to simulate an Item whose login is no longer valid. This makes it easy to test Link's update mode flow in the Sandbox environment. After calling /sandbox/user/reset_login, You can then use Plaid Link update mode to restore Items associated with the User to a good state. An ITEM_LOGIN_REQUIRED webhook will also be fired after a call to this endpoint, if one is associated with the Item.
In the Sandbox, Items will transition to an ITEM_LOGIN_REQUIRED error state automatically after 30 days, even if this endpoint is not called.

const request: SandboxUserResetLoginRequest = {
  user_token: 'user-environment-12345678-abcd-4bcd-abcd-1234567890ab',
  item_ids: ['eVBnVMp7zdTJLkRNr33Rs6zr7KNJqBFL9DrE6']
};
try {
  const response = await plaidClient.sandboxUserResetLogin(request);
} catch (error) {
  // handle error
}

The /sandbox/item/fire_webhook endpoint is used to test that code correctly handles webhooks. This endpoint can trigger the following webhooks:
DEFAULT_UPDATE: Webhook to be fired for a given Sandbox Item simulating a default update event for the respective product as specified with the webhook_type in the request body. Valid Sandbox DEFAULT_UPDATE webhook types include: AUTH, IDENTITY, TRANSACTIONS, INVESTMENTS_TRANSACTIONS, LIABILITIES, HOLDINGS. If the Item does not support the product, a SANDBOX_PRODUCT_NOT_ENABLED error will result.
NEW_ACCOUNTS_AVAILABLE: Fired to indicate that a new account is available on the Item and you can launch update mode to request access to it.
SMS_MICRODEPOSITS_VERIFICATION: Fired when a given same day micro-deposit item is verified via SMS verification.
LOGIN_REPAIRED: Fired when an Item recovers from the ITEM_LOGIN_REQUIRED without the user going through update mode in your app.
PENDING_DISCONNECT: Fired when an Item will stop working in the near future (e.g. due to a planned bank migration) and must be sent through update mode to continue working.
RECURRING_TRANSACTIONS_UPDATE: Recurring Transactions webhook to be fired for a given Sandbox Item. If the Item does not support Recurring Transactions, a SANDBOX_PRODUCT_NOT_ENABLED error will result.
SYNC_UPDATES_AVAILABLE: Transactions webhook to be fired for a given Sandbox Item. If the Item does not support Transactions, a SANDBOX_PRODUCT_NOT_ENABLED error will result.
PRODUCT_READY: Assets webhook to be fired when a given asset report has been successfully generated. If the Item does not support Assets, a SANDBOX_PRODUCT_NOT_ENABLED error will result.
ERROR: Assets webhook to be fired when asset report generation has failed. If the Item does not support Assets, a SANDBOX_PRODUCT_NOT_ENABLED error will result.
USER_PERMISSION_REVOKED: Indicates an end user has revoked the permission that they previously granted to access an Item. May not always fire upon revocation, as some institutions’ consent portals do not trigger this webhook. Upon receiving this webhook, it is recommended to delete any stored data from Plaid associated with the account or Item.
USER_ACCOUNT_REVOKED: Fired when an end user has revoked access to their account on the Data Provider's portal. This webhook is currently sent only for PNC Items, but may be sent in the future for other financial institutions. Upon receiving this webhook, it is recommended to delete any stored data from Plaid associated with the account or Item.
Note that this endpoint is provided for developer ease-of-use and is not required for testing webhooks; webhooks will also fire in Sandbox under the same conditions that they would in Production (except for webhooks of type TRANSFER).

// Fire a DEFAULT_UPDATE webhook for an Item
const request: SandboxItemFireWebhookRequest = {
  access_token: accessToken
  webhook_code: 'DEFAULT_UPDATE'
};
try {
  const response = await plaidClient.sandboxItemFireWebhook(request);
} catch (error) {
  // handle error
}

The /sandbox/item/set_verification_status endpoint can be used to change the verification status of an Item in in the Sandbox in order to simulate the Automated Micro-deposit flow.
For more information on testing Automated Micro-deposits in Sandbox, see Auth full coverage testing.

const request: SandboxItemSetVerificationStatusRequest = {
  access_token: accessToken,
  account_id: accountID,
  verification_status: 'automatically_verified',
};
try {
  const response = await plaidClient.sandboxItemSetVerificationStatus(request);
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/fire_webhook endpoint to manually trigger a TRANSFER_EVENTS_UPDATE webhook in the Sandbox environment.

const request: SandboxTransferFireWebhookRequest = {
  webhook: 'https://www.example.com',
};
try {
  const response = await plaidClient.sandboxTransferFireWebhook(request);
  // empty response upon success
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/simulate endpoint to simulate a transfer event in the Sandbox environment. Note that while an event will be simulated and will appear when using endpoints such as /transfer/event/sync or /transfer/event/list, no transactions will actually take place and funds will not move between accounts, even within the Sandbox.

const request: SandboxTransferSimulateRequest = {
  transfer_id,
  event_type: 'posted',
  failure_reason: failureReason,
};
try {
  const response = await plaidClient.sandboxTransferSimulate(request);
  // empty response upon success
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/refund/simulate endpoint to simulate a refund event in the Sandbox environment. Note that while an event will be simulated and will appear when using endpoints such as /transfer/event/sync or /transfer/event/list, no transactions will actually take place and funds will not move between accounts, even within the Sandbox.

const request: SandboxTransferRefundSimulateRequest = {
  refund_id: refundId,
  event_type: 'refund.posted',
};
try {
  const response = await plaidClient.sandboxTransferRefundSimulate(request);
  // empty response upon success
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/sweep/simulate endpoint to create a sweep and associated events in the Sandbox environment. Upon calling this endpoint, all transfers with a sweep status of swept will become swept_settled, all posted or pending transfers with a sweep status of unswept will become swept, and all returned transfers with a sweep status of swept will become return_swept.

try {
  const response = await plaidClient.sandboxTransferSweepSimulate({});
  const sweep = response.data.sweep;
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/ledger/deposit/simulate endpoint to simulate a ledger deposit event in the Sandbox environment.

const request: SandboxTransferLedgerDepositSimulateRequest = {
  sweep_id: 'f4ba7a287eae4d228d12331b68a9f35a',
  event_type: 'sweep.posted',
};
try {
  const response = await plaidClient.sandboxTransferLedgerDepositSimulate(
    request,
  );
  // empty response upon success
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/ledger/simulate_available endpoint to simulate converting pending balance to available balance for all originators in the Sandbox environment.

try {
  const response = await plaidClient.sandboxTransferLedgerSimulateAvailable({});
  const available = response.data.balance.available;
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/ledger/withdraw/simulate endpoint to simulate a ledger withdraw event in the Sandbox environment.

const request: SandboxTransferLedgerWithdrawSimulateRequest = {
  sweep_id: 'f4ba7a287eae4d228d12331b68a9f35a',
  event_type: 'sweep.posted',
};
try {
  const response = await plaidClient.sandboxTransferLedgerWithdrawSimulate(
    request,
  );
  // empty response upon success
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/test_clock/create endpoint to create a test_clock in the Sandbox environment.
A test clock object represents an independent timeline and has a virtual_time field indicating the current timestamp of the timeline. Test clocks are used for testing recurring transfers in Sandbox.
A test clock can be associated with up to 5 recurring transfers.

const request: SandboxTransferTestClockCreateRequest = {
  virtual_time: '2006-01-02T15:04:05Z',
};
try {
  const response = await plaidClient.sandboxTransferTestClockCreate(request);
  const test_clock = response.data.test_clock;
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/test_clock/advance endpoint to advance a test_clock in the Sandbox environment.
A test clock object represents an independent timeline and has a virtual_time field indicating the current timestamp of the timeline. A test clock can be advanced by incrementing virtual_time, but may never go back to a lower virtual_time.
If a test clock is advanced, we will simulate the changes that ought to occur during the time that elapsed.
For example, a client creates a weekly recurring transfer with a test clock set at t. When the client advances the test clock by setting virtual_time = t + 15 days, 2 new originations should be created, along with the webhook events.
The advancement of the test clock from its current virtual_time should be limited such that there are no more than 20 originations resulting from the advance operation on each recurring_transfer associated with the test_clock.
For example, if the recurring transfer associated with this test clock originates once every 4 weeks, you can advance the virtual_time up to 80 weeks on each API call.

const request: SandboxTransferTestClockAdvanceRequest = {
  test_clock_id: 'b33a6eda-5e97-5d64-244a-a9274110151c',
  new_virtual_time: '2006-01-02T15:04:05Z',
};
try {
  const response = await plaidClient.sandboxTransferTestClockAdvance(request);
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/test_clock/get endpoint to get a test_clock in the Sandbox environment.

const request: SandboxTransferTestClockGetRequest = {
  test_clock_id: 'b33a6eda-5e97-5d64-244a-a9274110151c',
};
try {
  const response = await plaidClient.sandboxTransferTestClockGet(request);
  const test_clock = response.data.test_clock;
} catch (error) {
  // handle error
}

Use the /sandbox/transfer/test_clock/list endpoint to see a list of all your test clocks in the Sandbox environment, by ascending virtual_time. Results are paginated; use the count and offset query parameters to retrieve the desired test clocks.

const request: SandboxTransferTestClockListRequest = {
  count: 2,
};
try {
  const response = await plaidClient.sandboxTransferTestClockList(request);
  const test_clocks = response.data.test_clocks;
} catch (error) {
  // handle error
}

Use the /sandbox/income/fire_webhook endpoint to manually trigger a Payroll or Document Income webhook in the Sandbox environment.

const request: SandboxIncomeFireWebhookRequest = {
  item_id: 'Rn3637v1adCNj5Dl1LG6idQBzqBLwRcRZLbgM',
  webhook: 'https://webhook.com/',
  verification_status: 'VERIFICATION_STATUS_PROCESSING_COMPLETE',
};
try {
  const response = await plaidClient.sandboxIncomeFireWebhook(request);
  // empty response upon success
} catch (error) {
  // handle error
}

Use the /sandbox/cra/cashflow_updates/update endpoint to manually trigger an update for Cash Flow Updates (Monitoring) in the Sandbox environment.

const request: SandboxCraCashflowUpdatesUpdateRequest = {
  user_token: 'user-environment-12345678-abcd-4bcd-abcd-1234567890ab',
  webhook_codes: ['LARGE_DEPOSIT_DETECTED', 'LOW_BALANCE_DETECTED'],
};
try {
  const response = await plaidClient.sandbox_cra_cashflow_updates_update(request);
  // empty response upon success
} catch (error) {
  // handle error
}

Use the /sandbox/payment/simulate endpoint to simulate various payment events in the Sandbox environment. This endpoint will trigger the corresponding payment status webhook.

const request: SandboxPaymentSimulateRequest = {
  payment_id: 'payment-id-sandbox-feca8a7a-5591-4aef-9297-f3062bb735d3',
  status: "PAYMENT_STATUS_INITIATED"
};
try {
  const response = await plaidClient.sandbox_payment_simulate(request);
} catch (error) {
  // handle error
}

Use the /sandbox/transactions/create endpoint to create new transactions for an existing Item. This endpoint can be used to add up to 10 transactions to any Item at a time.
This endpoint can only be used with Items that were created in the Sandbox environment using the user_transactions_dynamic test user. You can use this to add transactions to test the /transactions/get and /transactions/sync endpoints.

const request: SandboxTransactionsCreateRequest = {
  access_token: accessToken,
  transactions: [
    {
      amount: 100.50,
      date_posted: '2025-06-08',
      date_transacted: '2025-06-08',
      description: 'Tim Hortons'
    },
    {
      amount: -25.75,
      date_posted: '2025-06-08',
      date_transacted: '2025-06-08',
      description: 'BestBuy',
      iso_currency_code: 'CAD'
    }
  ]
};
try {
  const response = await plaidClient.sandbox_transactions_create(request);
} catch (error) {
  // handle error
}