Sandbox endpoints  ================== #### API reference for Sandbox endpoints  #### Introduction  Plaid's Sandbox environment provides a number of endpoints that can be used to configure testing scenarios. These endpoints are unique to the Sandbox environment and cannot be used in Production. For more information on these endpoints, see [Sandbox](https://plaid.com/docs/sandbox/index.html.md) . | In this section | | | --- | --- | | [/sandbox/public\_token/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxpublic_tokencreate) | Bypass the Link flow for creating an Item | | [/sandbox/processor\_token/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxprocessor_tokencreate) | Bypass the Link flow for creating an Item for a processor partner | | [/sandbox/item/reset\_login](https://plaid.com/docs/api/sandbox/index.html.md#sandboxitemreset_login) | Trigger the `ITEM_LOGIN_REQUIRED` state for an Item | | [/sandbox/user/reset\_login](https://plaid.com/docs/api/sandbox/index.html.md#sandboxuserreset_login) | (Income and Check) Force Item(s) for a Sandbox user into an error state | | [/sandbox/item/fire\_webhook](https://plaid.com/docs/api/sandbox/index.html.md#sandboxitemfire_webhook) | Fire a specific webhook | | [/sandbox/item/set\_verification\_status](https://plaid.com/docs/api/sandbox/index.html.md#sandboxitemset_verification_status) | (Auth) Set a verification status for testing micro-deposits | | [/sandbox/transfer/fire\_webhook](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferfire_webhook) | (Transfer) Fire a specific webhook | | [/sandbox/transfer/ledger/deposit/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferledgerdepositsimulate) | (Transfer) Simulate a deposit sweep event | | [/sandbox/transfer/ledger/simulate\_available](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferledgersimulate_available) | (Transfer) Simulate converting pending balance into available balance | | [/sandbox/transfer/ledger/withdraw/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferledgerwithdrawsimulate) | (Transfer) Simulate a withdraw sweep event | | [/sandbox/transfer/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfersimulate) | (Transfer) Simulate a transfer event | | [/sandbox/transfer/refund/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferrefundsimulate) | (Transfer) Simulate a refund event | | [/sandbox/transfer/test\_clock/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clockcreate) | (Transfer) Create a test clock for testing recurring transfers | | [/sandbox/transfer/test\_clock/advance](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clockadvance) | (Transfer) Advance the time on a test clock | | [/sandbox/transfer/test\_clock/get](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clockget) | (Transfer) Get details about a test clock | | [/sandbox/transfer/test\_clock/list](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clocklist) | (Transfer) Get details about all test clocks | | [/sandbox/income/fire\_webhook](https://plaid.com/docs/api/sandbox/index.html.md#sandboxincomefire_webhook) | (Income) Fire a specific webhook | | [/sandbox/cra/cashflow\_updates/update](https://plaid.com/docs/api/sandbox/index.html.md#sandboxcracashflow_updatesupdate) | (Check) Simulate an update for Cash Flow Updates | | [/sandbox/payment/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxpaymentsimulate) | (Payment Initiation) Simulate a payment | | [/sandbox/transactions/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransactionscreate) | (Transactions) Create custom transactions for Items | \=\*=\*=\*= #### /sandbox/public\_token/create  #### Create a test Item  Use the [/sandbox/public\_token/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxpublic_tokencreate) 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](https://plaid.com/docs/api/items/index.html.md#itempublic_tokenexchange) to exchange the `public_token` for an `access_token` and perform all API actions. [/sandbox/public\_token/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxpublic_tokencreate) can also be used with the [user\_custom test username](https://plaid.com/docs/sandbox/user-custom/index.html.md) to generate a test account with custom data, or with Plaid's [pre-populated Sandbox test accounts](https://plaid.com/docs/sandbox/test-credentials/index.html.md) . #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The ID of the institution the Item will be associated with required, \[string\] The products to initially pull for the Item. May be any products that the specified `institution_id` supports. This array may not be empty. Min items: `1` Possible values: `assets`, `auth`, `cra_base_report`, `cra_income_insights`, `cra_lend_score`, `cra_partner_insights`, `cra_monitoring`, `identity`, `income_verification`, `investments_auth`, `investments`, `liabilities`, `payment_initiation`, `signal`, `standing_orders`, `statements`, `transactions`, `transfer` object An optional set of options to be used when configuring the Item. If specified, must not be `null`. string Specify a webhook to associate with the new Item. Format: `url` string Test username to use for the creation of the Sandbox Item. Default value is `user_good`. Default: `user_good` string Test password to use for the creation of the Sandbox Item. Default value is `pass_good`. Default: `pass_good` object An optional set of parameters corresponding to transactions options. string The earliest date for which to fetch transaction history. Dates should be formatted as YYYY-MM-DD. Format: `date` string The most recent date for which to fetch transaction history. Dates should be formatted as YYYY-MM-DD. Format: `date` object An optional set of parameters corresponding to statements options. required, string The earliest date for which to fetch statements history. Dates should be formatted as YYYY-MM-DD. Format: `date` required, string The most recent date for which to fetch statements history. Dates should be formatted as YYYY-MM-DD. Format: `date` object A set of parameters for income verification options. This field is required if `income_verification` is included in the `initial_products` array. \[string\] The types of source income data that users will be permitted to share. Options include `bank` and `payroll`. Currently you can only specify one of these options. Possible values: `bank`, `payroll` object Specifies options for Bank Income. This field is required if `income_verification` is included in the `initial_products` array and `bank` is specified in `income_source_types`. integer The number of days of data to request for the Bank Income product string The user token associated with the user for which data is being requested. This field is used only by customers with pre-existing integrations that already use the `user_token` field. All other customers should use the `user_id` instead. For more details, see [New User APIs](https://plaid.com/docs/api/users/user-apis/index.html.md) . string A unique user identifier, created by `/user/create`. Integrations that began using `/user/create` after December 10, 2025 use this field to identify a user instead of the `user_token`. For more details, see [New User APIs](https://plaid.com/docs/api/users/user-apis/index.html.md) . ```bash curl -X POST https://sandbox.plaid.com/sandbox/public_token/create \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "institution_id": String, "initial_products": [String], "options": { "webhook": String, "override_username": String, "override_password": String } }' ``` ```node 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 } ``` ```python pt_request = SandboxPublicTokenCreateRequest( institution_id=INSTITUTION_ID, initial_products=[Products('transactions')] ) pt_response = client.sandbox_public_token_create(pt_request) # The generated public_token can now be # exchanged for an access_token exchange_request = ItemPublicTokenExchangeRequest( public_token=pt_response['public_token'] ) exchange_response = client.item_public_token_exchange(exchange_request) ``` ```java SandboxPublicTokenCreateRequest createRequest = new SandboxPublicTokenCreateRequest() .institutionId(TARTAN_BANK_INSTITUTION_ID) .initialProducts(Arrays.asList(Products.AUTH)); Response createResponse = client .sandboxPublicTokenCreate(createRequest) .execute(); // The generated public_token can now be // exchanged for an access_token ItemPublicTokenExchangeRequest exchangeRequest = new ItemPublicTokenExchangeRequest() .publicToken(createResponse.body().getPublicToken()); Response response = client .itemPublicTokenExchange(exchangeRequest) .execute(); ``` ```ruby request = Plaid::SandboxPublicTokenCreateRequest.new( { institution_id: SANDBOX_INSTITUTION, initial_products: ["transactions"] } ) response = client.sandbox_public_token_create(request) # The generated public_token can now be # exchanged for an access_token publicToken = response.public_token item_public_token_exchange_request = Plaid::ItemPublicTokenExchangeRequest.new( { public_token: publicToken } ) response = client.item_public_token_exchange(item_public_token_exchange_request) ``` ```go sandboxPublicTokenResp, _, err := client.PlaidApi.SandboxPublicTokenCreate(ctx).SandboxPublicTokenCreateRequest( *plaid.NewSandboxPublicTokenCreateRequest( institutionID, products, ), ).Execute() // exchange the public_token for an access_token exchangePublicTokenResp, _, err := client.PlaidApi.ItemPublicTokenExchange(ctx).ItemPublicTokenExchangeRequest( *plaid.NewItemPublicTokenExchangeRequest(sandboxPublicTokenResp.GetPublicToken()), ).Execute() ``` #### Response fields  string A public token that can be exchanged for an access token using `/item/public_token/exchange` string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "public_token": "public-sandbox-b0e2c4ee-a763-4df5-bfe9-46a46bce993d", "request_id": "Aim3b" } ``` \=\*=\*=\*= #### /sandbox/processor\_token/create  #### Create a test Item and processor token  Use the [/sandbox/processor\_token/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxprocessor_tokencreate) 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](https://plaid.com/docs/api/sandbox/index.html.md#sandboxprocessor_tokencreate) with the [user\_custom test username](https://plaid.com/docs/sandbox/user-custom/index.html.md) to generate a test account with custom data. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The ID of the institution the Item will be associated with object An optional set of options to be used when configuring the Item. If specified, must not be `null`. string Test username to use for the creation of the Sandbox Item. Default value is `user_good`. Default: `user_good` string Test password to use for the creation of the Sandbox Item. Default value is `pass_good`. Default: `pass_good` ```bash curl -X POST https://sandbox.plaid.com/sandbox/processor_token/create \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "institution_id": String, "options": { "override_username": String, "override_password": String } }' ``` ```node const request: SandboxProcessorTokenCreateRequest = { institution_id: institutionID, }; try { const response = await plaidClient.sandboxProcessorTokenCreate(request); const processorToken = response.data.processor_token; } catch (error) { // handle error } ``` ```python request = SandboxProcessorTokenCreateRequest(institution_id=INSTITUTION_ID) response = client.sandbox_processor_token_create(request) processor_token = response['processor_token'] # The generated processor_token can now be used to call # processor endpoints. These endpoints are not currently # accessible via the client libraries. ``` ```java SandboxProcessorTokenCreateRequest request = new SandboxProcessorTokenCreateRequest() .institutionId(INSTITUTION_ID); Response response = client() .sandboxProcessorTokenCreate(request) .execute(); String processorToken = response.body().getProcessorToken(); // The generated processor_token can now be used to call // processor endpoints. These endpoints are not currently // accessible via the client libraries. ``` ```ruby request = Plaid::SandboxProcessorTokenCreateRequest.new( { institution_id: INSTITUTION_ID } ) response = client.sandbox_processor_token_create(request) processor_token = response.processor_token # The generated processor_token can now be used to call # processor endpoints. These endpoints are not currently # accessible via the client libraries. ``` ```go request := plaid.NewSandboxProcessorTokenCreateRequest("INSTITUTION_ID") processorTokenResp, _, err := client.PlaidApi.SandboxProcessorTokenCreate(ctx).SandboxProcessorTokenCreateRequest( *request, ).Execute() ``` #### Response fields  string A processor token that can be used to call the `/processor/` endpoints. string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "processor_token": "processor-sandbox-b0e2c4ee-a763-4df5-bfe9-46a46bce993d", "request_id": "Aim3b" } ``` \=\*=\*=\*= #### /sandbox/item/reset\_login  #### Force a Sandbox Item into an error state  `/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](https://plaid.com/docs/link/update-mode/index.html.md) flow in the Sandbox environment. After calling [/sandbox/item/reset\_login](https://plaid.com/docs/api/sandbox/index.html.md#sandboxitemreset_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. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The access token associated with the Item for which data is being requested. ```bash curl -X POST https://sandbox.plaid.com/sandbox/item/reset_login \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "access_token": String }' ``` ```node const request: SandboxItemResetLoginRequest = { access_token: accessToken, }; try { const response = await plaidClient.sandboxItemResetLogin(request); } catch (error) { // handle error } ``` ```python # force a Sandbox Item into an ITEM_LOGIN_REQUIRED state request = SandboxItemResetLoginRequest(access_token=access_token) response = client.sandbox_item_reset_login(request) ``` ```java SandboxItemResetLoginRequest request = new SandboxItemResetLoginRequest() .accessToken(accessToken); Response response = client() .sandboxItemResetLogin(request) .execute(); ``` ```ruby # force a Sandbox Item into an error state request = Plaid::SandboxItemResetLoginRequest.new({ access_token: accessToken }) response = client.sandbox_item_reset_login(request) ``` ```go // force a Sandbox Item into an error state resetResp, _, err := client.PlaidApi.SandboxItemResetLogin(ctx).SandboxItemResetLoginRequest( *plaid.NewSandboxItemResetLoginRequest( accessToken, ), ).Execute() // create a public_token for the Item and use it to // initialize Link in update mode. publicTokenResp, _, err := client.PlaidApi.ItemCreatePublicToken(ctx).ItemPublicTokenCreateRequest( *plaid.NewItemPublicTokenCreateRequest( accessToken, ), ).Execute() ``` #### Response fields  boolean `true` if the call succeeded string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "reset_login": true, "request_id": "m8MDnv9okwxFNBV" } ``` \=\*=\*=\*= #### /sandbox/user/reset\_login  #### Force item(s) for a Sandbox User into an error state  `/sandbox/user/reset_login/` functions the same as [/sandbox/item/reset\_login](https://plaid.com/docs/api/sandbox/index.html.md#sandboxitemreset_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](https://plaid.com/docs/link/update-mode/index.html.md) flow in the Sandbox environment. After calling [/sandbox/user/reset\_login](https://plaid.com/docs/api/sandbox/index.html.md#sandboxuserreset_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. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. string The user token associated with the user for which data is being requested. This field is used only by customers with pre-existing integrations that already use the `user_token` field. All other customers should use the `user_id` instead. For more details, see [New User APIs](https://plaid.com/docs/api/users/user-apis/index.html.md) . \[string\] An array of `item_id`s associated with the User to be reset. If empty or `null`, this field will default to resetting all Items associated with the User. string A unique user identifier, created by `/user/create`. Integrations that began using `/user/create` after December 10, 2025 use this field to identify a user instead of the `user_token`. For more details, see [New User APIs](https://plaid.com/docs/api/users/user-apis/index.html.md) . ```bash curl -X POST https://sandbox.plaid.com/sandbox/user/reset_login \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "user_id": "usr_9nSp2KuZ2x4JDw", "item_ids": [ "eVBnVMp7zdTJLkRNr33Rs6zr7KNJqBFL9DrE6", ] }' ``` ```node const request: SandboxUserResetLoginRequest = { user_id: 'usr_9nSp2KuZ2x4JDw', item_ids: ['eVBnVMp7zdTJLkRNr33Rs6zr7KNJqBFL9DrE6'] }; try { const response = await plaidClient.sandboxUserResetLogin(request); } catch (error) { // handle error } ``` ```python # force a Sandbox Item for a user into an error state request = SandboxUserResetLoginRequest( user_id='usr_9nSp2KuZ2x4JDw', item_ids=['eVBnVMp7zdTJLkRNr33Rs6zr7KNJqBFL9DrE6'] ) response = client.sandbox_user_reset_login(request) ``` ```java // force a Sandbox Item for a user into an error state SandboxUserResetLoginRequest request = new SandboxUserResetLoginRequest() .userId("usr_9nSp2KuZ2x4JDw") .itemIds(Arrays.asList( "eVBnVMp7zdTJLkRNr33Rs6zr7KNJqBFL9DrE6" )); Response response = client() .sandboxUserResetLogin(request) .execute(); ``` ```ruby # force a Sandbox Item for a user into an error state request = Plaid::SandboxUserResetLoginRequest.new({ user_id: "usr_9nSp2KuZ2x4JDw", item_ids: ["eVBnVMp7zdTJLkRNr33Rs6zr7KNJqBFL9DrE6"] }) response = client.sandbox_user_reset_login(request) ``` ```go // force a Sandbox Item for a user into an error state request := plaid.SandboxUserResetLoginRequest{ UserId: plaid.PtrString("usr_9nSp2KuZ2x4JDw"), ItemIds: []string{"eVBnVMp7zdTJLkRNr33Rs6zr7KNJqBFL9DrE6"}, } resetResp, _, err := client.PlaidApi. SandboxUserResetLogin(ctx). SandboxUserResetLoginRequest(request). Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "n7XQnv8ozwyFPBC" } ``` \=\*=\*=\*= #### /sandbox/item/fire\_webhook  #### Fire a test webhook  The [/sandbox/item/fire\_webhook](https://plaid.com/docs/api/sandbox/index.html.md#sandboxitemfire_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`). #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The access token associated with the Item for which data is being requested. string The webhook types that can be fired by this test endpoint. Possible values: `AUTH`, `HOLDINGS`, `INVESTMENTS_TRANSACTIONS`, `ITEM`, `LIABILITIES`, `TRANSACTIONS`, `ASSETS` required, string The webhook codes that can be fired by this test endpoint. Possible values: `DEFAULT_UPDATE`, `NEW_ACCOUNTS_AVAILABLE`, `SMS_MICRODEPOSITS_VERIFICATION`, `USER_PERMISSION_REVOKED`, `USER_ACCOUNT_REVOKED`, `PENDING_DISCONNECT`, `RECURRING_TRANSACTIONS_UPDATE`, `LOGIN_REPAIRED`, `SYNC_UPDATES_AVAILABLE`, `PRODUCT_READY`, `ERROR` ```bash curl -X POST https://sandbox.plaid.com/sandbox/item/fire_webhook \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "access_token": String, "webhook_code": String }' ``` ```node // 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 } ``` ```python # fire a DEFAULT_UPDATE webhook for an item request = SandboxItemFireWebhookRequest( access_token=access_token, webhook_code='DEFAULT_UPDATE' ) response = client.sandbox_item_fire_webhook(request) ``` ```java // fire a DEFAULT_UPDATE webhook for an Item SandboxItemFireWebhookRequest request = new SandboxItemFireWebhookRequest() .accessToken(accessToken) .webhookCode("DEFAULT_UPDATE"); Response response = client() .sandboxItemFireWebhook(request) .execute(); ``` ```ruby # fire a DEFAULT_UPDATE webhook for an item request = Plaid::SandboxItemFireWebhookRequest.new( { access_token: access_token, webhook_code: "DEFAULT_UPDATE" } ) response = client.sandbox_item_fire_webhook(request) ``` ```go request := plaid.NewSandboxItemFireWebhookRequest(accessToken, "DEFAULT_UPDATE") fireWebhookResp, _, err := client.PlaidApi.SandboxItemFireWebhook(ctx).SandboxItemFireWebhookRequest( *request, ).Execute() ``` #### Response fields  boolean Value is `true` if the test `webhook_code` was successfully fired. string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "webhook_fired": true, "request_id": "1vwmF5TBQwiqfwP" } ``` \=\*=\*=\*= #### /sandbox/item/set\_verification\_status  #### Set verification status for Sandbox account  The [/sandbox/item/set\_verification\_status](https://plaid.com/docs/api/sandbox/index.html.md#sandboxitemset_verification_status) endpoint can be used to change the verification status of an Item 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](https://plaid.com/docs/auth/coverage/testing/index.html.md#) . #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The access token associated with the Item for which data is being requested. required, string The `account_id` of the account whose verification status is to be modified required, string The verification status to set the account to. Possible values: `automatically_verified`, `verification_expired` ```bash curl -X POST https://sandbox.plaid.com/sandbox/item/set_verification_status \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "access_token": String, "account_id": String, "verification_status": String }' ``` ```node const request: SandboxItemSetVerificationStatusRequest = { access_token: accessToken, account_id: accountID, verification_status: 'automatically_verified', }; try { const response = await plaidClient.sandboxItemSetVerificationStatus(request); } catch (error) { // handle error } ``` ```python # Set the verification_status for an Item created using Automated Microdeposits, triggering a webhook request = SandboxItemSetVerificationStatusRequest( access_token=access_token, account_id=account_id, verification_status="automatically_verified" ) response = client.sandbox_item_set_verification_status(request) ``` ```java // Set the verification_status for an Item created using Automated Microdeposits, triggering a webhook SandboxItemSetVerificationStatusRequest request = new SandboxItemSetVerificationStatusRequest() .accessToken(accessToken) .accountId(accountId) .verificationStatus("automatically_verified"); Response response = client() .sandboxItemSetVerificationStatus(request) .execute(); ``` ```ruby # Set the verification_status for an Item created using Automated Microdeposits, triggering a webhook request = Plaid::SandboxItemSetVerificationStatusRequest.new( { access_token: access_token, account_id: account_id, verification_status: 'automatically_verified' } ) response = client.sandbox_item_set_verification_status(request) ``` ```go // Set the verification_status for an Item created using Automated Microdeposits, triggering a webhook setVerificationStatusResp, _, err := client.PlaidApi.SandboxItemSetVerificationStatus(ctx).SandboxItemSetVerificationStatusRequest( *plaid.NewSandboxItemSetVerificationStatusRequest( accessToken, accountID, "automatically_verified", ), ).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "1vwmF5TBQwiqfwP" } ``` \=\*=\*=\*= #### /sandbox/transfer/fire\_webhook  #### Manually fire a Transfer webhook  Use the [/sandbox/transfer/fire\_webhook](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferfire_webhook) endpoint to manually trigger a `TRANSFER_EVENTS_UPDATE` webhook in the Sandbox environment. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The URL to which the webhook should be sent. Format: `url` ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/fire_webhook \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "webhook": String }' ``` ```node const request: SandboxTransferFireWebhookRequest = { webhook: 'https://www.example.com', }; try { const response = await plaidClient.sandboxTransferFireWebhook(request); // empty response upon success } catch (error) { // handle error } ``` ```python response = client.Sandbox.transfer.fire_webhook( webhook_url, ) # empty response upon success ``` ```java SandboxTransferFireWebhookRequest request = new SandboxTransferFireWebhookRequest() .webhook(webhookUrl); Response response = client() .sandboxTransferFireWebhook(request) .execute(); // empty response upon success ``` ```ruby request = Plaid::SandboxTransferFireWebhookRequest.new( { webhook: "https://www.example.com" } ) response = client.sandbox_transfer_fire_webhook(request) # empty response upon success ``` ```go request := plaid.NewSandboxTransferFireWebhookRequest(webhookUrl) response, _, err := client.PlaidApi.SandboxTransferFireWebhook(ctx).SandboxTransferFireWebhookRequest( *request, ).Execute() // empty response upon success ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/simulate  #### Simulate a transfer event in Sandbox  Use the [/sandbox/transfer/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfersimulate) 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](https://plaid.com/docs/api/products/transfer/reading-transfers/index.html.md#transfereventsync) or [/transfer/event/list](https://plaid.com/docs/api/products/transfer/reading-transfers/index.html.md#transfereventlist) , no transactions will actually take place and funds will not move between accounts, even within the Sandbox. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string Plaid's unique identifier for a transfer. string Plaid's unique identifier for a test clock. If provided, the event to be simulated is created at the `virtual_time` on the provided `test_clock`. required, string The asynchronous event to be simulated. May be: `posted`, `settled`, `failed`, `funds_available`, or `returned`. An error will be returned if the event type is incompatible with the current transfer status. Compatible status --> event type transitions include: `pending` --> `failed` `pending` --> `posted` `posted` --> `returned` `posted` --> `settled` `settled` --> `funds_available` (only applicable to ACH debits.) object The failure reason if the event type for a transfer is `"failed"` or `"returned"`. Null value otherwise. string The failure code, e.g. `R01`. A failure code will be provided if and only if the transfer status is `returned`. See [ACH return codes](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) for a full listing of ACH return codes and [RTP/RfP error codes](https://plaid.com/docs/errors/transfer/index.html.md#rtprfp-error-codes) for RTP error codes. deprecated, string The ACH return code, e.g. `R01`. A return code will be provided if and only if the transfer status is `returned`. For a full listing of ACH return codes, see [Transfer errors](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) . string A human-readable description of the reason for the failure or reversal. string The webhook URL to which a `TRANSFER_EVENTS_UPDATE` webhook should be sent. Format: `url` ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/simulate \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "transfer_id": "123004561178933", "event_type": "posted" }' ``` ```node 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 } ``` ```python request = SandboxTransferSimulateRequest( transfer_id=transfer_id, event_type='posted', failure_reason='failed' ) response = client.sandbox_transfer_simulate(request) # empty response upon success ``` ```java SandboxTransferSimulateRequest request = new SandboxTransferSimulateRequest() .transferId(getTransfer().getId()) .eventType("posted"); Response simulateResponse = client() .sandboxTransferSimulate(request) .execute(); // empty response upon success ``` ```ruby request = Plaid::SandboxTransferSimulateRequest.new( { transfer_id: transfer_id, event_type: 'posted', failure_reason: 'failed' } ) response = client.sandbox_transfer_simulate(request) # empty response upon success ``` ```go request := plaid.NewSandboxTransferSimulateRequest("TRANSFER_ID", "posted") transferSimulateResp, _, err := client.PlaidApi.SandboxTransferSimulate(ctx).SandboxTransferSimulateRequest( *request, ).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/refund/simulate  #### Simulate a refund event in Sandbox  Use the [/sandbox/transfer/refund/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferrefundsimulate) 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](https://plaid.com/docs/api/products/transfer/reading-transfers/index.html.md#transfereventsync) or [/transfer/event/list](https://plaid.com/docs/api/products/transfer/reading-transfers/index.html.md#transfereventlist) , no transactions will actually take place and funds will not move between accounts, even within the Sandbox. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string Plaid's unique identifier for a refund. string Plaid's unique identifier for a test clock. If provided, the event to be simulated is created at the `virtual_time` on the provided `test_clock`. required, string The asynchronous event to be simulated. May be: `refund.posted`, `refund.settled`, `refund.failed`, or `refund.returned`. An error will be returned if the event type is incompatible with the current refund status. Compatible status --> event type transitions include: `refund.pending` --> `refund.failed` `refund.pending` --> `refund.posted` `refund.posted` --> `refund.returned` `refund.posted` --> `refund.settled` `refund.posted` events can only be simulated if the refunded transfer has been transitioned to settled. This mimics the ordering of events in Production. object The failure reason if the event type for a transfer is `"failed"` or `"returned"`. Null value otherwise. string The failure code, e.g. `R01`. A failure code will be provided if and only if the transfer status is `returned`. See [ACH return codes](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) for a full listing of ACH return codes and [RTP/RfP error codes](https://plaid.com/docs/errors/transfer/index.html.md#rtprfp-error-codes) for RTP error codes. deprecated, string The ACH return code, e.g. `R01`. A return code will be provided if and only if the transfer status is `returned`. For a full listing of ACH return codes, see [Transfer errors](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) . string A human-readable description of the reason for the failure or reversal. string The webhook URL to which a `TRANSFER_EVENTS_UPDATE` webhook should be sent. Format: `url` ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/refund/simulate \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "refund_id": "123004561178933", "event_type": "refund.posted" }' ``` ```node 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 } ``` ```python request = SandboxTransferRefundSimulateRequest( refund_id=refund_id, event_type='refund.posted' ) response = client.sandbox_transfer_refund_simulate(request) # empty response upon success ``` ```java SandboxTransferRefundSimulateRequest request = new SandboxTransferRefundSimulateRequest() .refundId(getRefund().getId()) .eventType("refund.posted"); Response response = client() .sandboxTransferRefundSimulate(request) .execute(); // empty response upon success ``` ```ruby request = Plaid::SandboxTransferRefundSimulateRequest.new( { refund_id: refund_id, event_type: 'refund.posted' } ) response = client.sandbox_transfer_refund_simulate(request) # empty response upon success ``` ```go request := plaid.NewSandboxTransferRefundSimulateRequest(refundID, "refund.posted") response, _, err := client.PlaidApi.SandboxTransferRefundSimulate(ctx).SandboxTransferRefundSimulateRequest( *request, ).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/ledger/deposit/simulate  #### Simulate a ledger deposit event in Sandbox  Use the [/sandbox/transfer/ledger/deposit/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferledgerdepositsimulate) endpoint to simulate a ledger deposit event in the Sandbox environment. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string Plaid's unique identifier for a sweep. required, string The asynchronous event to be simulated. May be: `posted`, `settled`, `failed`, or `returned`. An error will be returned if the event type is incompatible with the current ledger sweep status. Compatible status --> event type transitions include: `sweep.pending` --> `sweep.posted` `sweep.pending` --> `sweep.failed` `sweep.posted` --> `sweep.settled` `sweep.posted` --> `sweep.returned` `sweep.settled` --> `sweep.returned` Possible values: `sweep.posted`, `sweep.settled`, `sweep.returned`, `sweep.failed` object The failure reason if the event type for a transfer is `"failed"` or `"returned"`. Null value otherwise. string The failure code, e.g. `R01`. A failure code will be provided if and only if the transfer status is `returned`. See [ACH return codes](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) for a full listing of ACH return codes and [RTP/RfP error codes](https://plaid.com/docs/errors/transfer/index.html.md#rtprfp-error-codes) for RTP error codes. deprecated, string The ACH return code, e.g. `R01`. A return code will be provided if and only if the transfer status is `returned`. For a full listing of ACH return codes, see [Transfer errors](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) . string A human-readable description of the reason for the failure or reversal. ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/ledger/deposit/simulate \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "sweep_id": "f4ba7a287eae4d228d12331b68a9f35a", "event_type": "sweep.posted" }' ``` ```node 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 } ``` ```python request = SandboxTransferLedgerDepositSimulateRequest( sweep_id=sweep_id, event_type='sweep.posted' ) response = client.sandbox_transfer_ledger_deposit_simulate(request) # empty response upon success ``` ```java SandboxTransferLedgerDepositSimulateRequest request = new SandboxTransferLedgerDepositSimulateRequest() .sweepId("f4ba7a287eae4d228d12331b68a9f35a") .eventType("sweep.posted"); Response simulateResponse = client() .sandboxTransferLedgerDepositSimulate(request) .execute(); // empty response upon success ``` ```ruby request = Plaid::SandboxTransferLedgerDepositSimulateRequest.new( { sweep_id: sweep_id, event_type: 'sweep.posted' } ) response = client.sandbox_transfer_ledger_deposit_simulate(request) # empty response upon success ``` ```go request := plaid.NewSandboxTransferLedgerDepositSimulateRequest("SWEEP_ID", "sweep.posted") transferLedgerDepositSimulateResp, _, err := client.PlaidApi.SandboxTransferLedgerDepositSimulate(ctx).SandboxTransferLedgerDepositSimulateRequest( *request, ).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/ledger/simulate\_available  #### Simulate converting pending balance to available balance  Use the [/sandbox/transfer/ledger/simulate\_available](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferledgersimulate_available) endpoint to simulate converting pending balance to available balance for all originators in the Sandbox environment. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. string Specify which ledger balance to simulate converting pending balance to available balance. If this field is left blank, this will default to id of the default ledger balance. string Client ID of the end customer (i.e. the originator). Only applicable to Transfer for Platforms customers. string Plaid's unique identifier for a test clock. If provided, only the pending balance that is due before the `virtual_timestamp` on the test clock will be converted. string The webhook URL to which a `TRANSFER_EVENTS_UPDATE` webhook should be sent. Format: `url` ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/ledger/simulate_available \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}" }' ``` ```node try { const response = await plaidClient.sandboxTransferLedgerSimulateAvailable({}); const available = response.data.balance.available; } catch (error) { // handle error } ``` ```python response = client.sandbox_transfer_ledger_simulate_available({}) balance = response['balance'] ``` ```java Response response = client().sandboxTransferLedgerSimulateAvailable(new Object()).execute(); Balance balance = response.body().getBalance(); ``` ```ruby response = client.sandbox_transfer_ledger_simulate_available({}) balance = response.balance ``` ```go resp, _, err := client.PlaidApi.SandboxTransferLedgerSimulateAvailable(ctx).Body(nil).Execute() if err != nil { plaidErr, _ := plaid.ToPlaidError(err) fmt.Println(plaidErr.ErrorMessage) } balance, ok := resp.GetBalance() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/ledger/withdraw/simulate  #### Simulate a ledger withdraw event in Sandbox  Use the [/sandbox/transfer/ledger/withdraw/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransferledgerwithdrawsimulate) endpoint to simulate a ledger withdraw event in the Sandbox environment. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string Plaid's unique identifier for a sweep. required, string The asynchronous event to be simulated. May be: `posted`, `settled`, `failed`, or `returned`. An error will be returned if the event type is incompatible with the current ledger sweep status. Compatible status --> event type transitions include: `sweep.pending` --> `sweep.posted` `sweep.pending` --> `sweep.failed` `sweep.posted` --> `sweep.settled` `sweep.posted` --> `sweep.returned` `sweep.settled` --> `sweep.returned` Possible values: `sweep.posted`, `sweep.settled`, `sweep.returned`, `sweep.failed` object The failure reason if the event type for a transfer is `"failed"` or `"returned"`. Null value otherwise. string The failure code, e.g. `R01`. A failure code will be provided if and only if the transfer status is `returned`. See [ACH return codes](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) for a full listing of ACH return codes and [RTP/RfP error codes](https://plaid.com/docs/errors/transfer/index.html.md#rtprfp-error-codes) for RTP error codes. deprecated, string The ACH return code, e.g. `R01`. A return code will be provided if and only if the transfer status is `returned`. For a full listing of ACH return codes, see [Transfer errors](https://plaid.com/docs/errors/transfer/index.html.md#ach-return-codes) . string A human-readable description of the reason for the failure or reversal. ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/ledger/withdraw/simulate \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "sweep_id": "f4ba7a287eae4d228d12331b68a9f35a", "event_type": "sweep.posted" }' ``` ```node 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 } ``` ```python request = SandboxTransferLedgerWithdrawSimulateRequest( sweep_id=sweep_id, event_type='sweep.posted' ) response = client.sandbox_transfer_ledger_withdraw_simulate(request) # empty response upon success ``` ```java SandboxTransferLedgerWithdrawSimulateRequest request = new SandboxTransferLedgerWithdrawSimulateRequest() .sweepId("f4ba7a287eae4d228d12331b68a9f35a") .eventType("sweep.posted"); Response simulateResponse = client() .sandboxTransferLedgerWithdrawSimulate(request) .execute(); // empty response upon success ``` ```ruby request = Plaid::SandboxTransferLedgerWithdrawSimulateRequest.new( { sweep_id: sweep_id, event_type: 'sweep.posted' } ) response = client.sandbox_transfer_ledger_withdraw_simulate(request) # empty response upon success ``` ```go request := plaid.NewSandboxTransferLedgerWithdrawSimulateRequest("SWEEP_ID", "sweep.posted") transferLedgerWithdrawSimulateResp, _, err := client.PlaidApi.SandboxTransferLedgerWithdrawSimulate(ctx).SandboxTransferLedgerWithdrawSimulateRequest( *request, ).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/test\_clock/create  #### Create a test clock  Use the [/sandbox/transfer/test\_clock/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clockcreate) 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. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. string The virtual timestamp on the test clock. If not provided, the current timestamp will be used. This will be of the form `2006-01-02T15:04:05Z`. Format: `date-time` ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/test_clock/create \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "virtual_time": "2006-01-02T15:04:05Z" }' ``` ```node 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 } ``` ```python request = SandboxTransferTestClockCreateRequest( virtual_time='2006-01-02T15:04:05Z' ) response = client.sandbox_transfer_test_clock_create(request) test_clock = response['test_clock'] ``` ```java SandboxTransferTestClockCreateRequest request = new SandboxTransferTestClockCreateRequest() .virtualTime("2006-01-02T15:04:05Z"); Response testClockCreateResponse = client() .sandboxTransferTestClockCreate(request) .execute(); TestClock testClock = testClockCreateResponse.body().getTestClock(); ``` ```ruby request = Plaid::SandboxTransferTestClockCreateRequest.new( { virtual_time: '2006-01-02T15:04:05Z', } ) response = client.sandbox_transfer_test_clock_create(request) test_clock = response.test_clock ``` ```go layout := "2006-01-02T15:04:05.000Z" virtualTime, _ := time.Parse(layout, "2006-01-02T15:04:05Z") request := plaid.NewSandboxTransferTestClockCreateRequest(); request.SetVirtualTime(virtualTime); resp, _, err := client.PlaidApi.SandboxTransferTestClockCreate(ctx).SandboxTransferTestClockCreateRequest(*request).Execute() if err != nil { plaidErr, _ := plaid.ToPlaidError(err) fmt.Println(plaidErr.ErrorMessage) } testClock, ok := resp.GetTestClock() if ok { fmt.Printf("created test_clock %v\n", testClock) } ``` #### Response fields  object Defines the test clock for a transfer. string Plaid's unique identifier for a test clock. This field is only populated in the Sandbox environment, and only if a `test_clock_id` was included in the `/transfer/recurring/create` request. For more details, see [Simulating recurring transfers](https://plaid.com/docs/transfer/sandbox/index.html.md#simulating-recurring-transfers) . string The virtual timestamp on the test clock. This will be of the form `2006-01-02T15:04:05Z`. Format: `date-time` string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "test_clock": { "test_clock_id": "b33a6eda-5e97-5d64-244a-a9274110151c", "virtual_time": "2006-01-02T15:04:05Z" }, "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/test\_clock/advance  #### Advance a test clock  Use the [/sandbox/transfer/test\_clock/advance](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clockadvance) 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. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string Plaid's unique identifier for a test clock. This field is only populated in the Sandbox environment, and only if a `test_clock_id` was included in the `/transfer/recurring/create` request. For more details, see [Simulating recurring transfers](https://plaid.com/docs/transfer/sandbox/index.html.md#simulating-recurring-transfers) . required, string The virtual timestamp on the test clock. This will be of the form `2006-01-02T15:04:05Z`. Format: `date-time` ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/test_clock/advance \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "test_clock_id": "b33a6eda-5e97-5d64-244a-a9274110151c", "new_virtual_time": "2006-01-02T15:04:05Z" }' ``` ```node 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 } ``` ```python request = SandboxTransferTestClockAdvanceRequest( test_clock_id='b33a6eda-5e97-5d64-244a-a9274110151c', new_virtual_time='2006-01-02T15:04:05Z' ) response = client.sandbox_transfer_test_clock_advance(request) ``` ```java SandboxTransferTestClockAdvanceRequest request = new SandboxTransferTestClockAdvanceRequest() .testClockId("b33a6eda-5e97-5d64-244a-a9274110151c") .newVirtualTime("2006-01-02T15:04:05Z"); Response testClockAdvanceResponse = client() .sandboxTransferTestClockAdvance(request) .execute(); ``` ```ruby request = Plaid::SandboxTransferTestClockAdvanceRequest.new( { test_clock_id: 'b33a6eda-5e97-5d64-244a-a9274110151c', new_virtual_time: '2006-01-02T15:04:05Z' } ) response = client.sandbox_transfer_test_clock_advance(request) ``` ```go layout := "2006-01-02T15:04:05.000Z" newVirtualTime, _ := time.Parse(layout, "2006-01-02T15:04:05Z") request := plaid.NewSandboxTransferTestClockAdvanceRequest("b33a6eda-5e97-5d64-244a-a9274110151c", newVirtualTime) resp, _, err := client.PlaidApi.SandboxTransferTestClockAdvance(ctx).SandboxTransferTestClockAdvanceRequest(*request).Execute() if err != nil { plaidErr, _ := plaid.ToPlaidError(err) fmt.Println(plaidErr.ErrorMessage) } ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/test\_clock/get  #### Get a test clock  Use the [/sandbox/transfer/test\_clock/get](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clockget) endpoint to get a `test_clock` in the Sandbox environment. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string Plaid's unique identifier for a test clock. This field is only populated in the Sandbox environment, and only if a `test_clock_id` was included in the `/transfer/recurring/create` request. For more details, see [Simulating recurring transfers](https://plaid.com/docs/transfer/sandbox/index.html.md#simulating-recurring-transfers) . ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/test_clock/get \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "test_clock_id": "b33a6eda-5e97-5d64-244a-a9274110151c" }' ``` ```node 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 } ``` ```python request = SandboxTransferTestClockGetRequest( test_clock_id='b33a6eda-5e97-5d64-244a-a9274110151c' ) response = client.sandbox_transfer_test_clock_get(request) test_clock = response['test_clock'] ``` ```java SandboxTransferTestClockGetRequest request = new SandboxTransferTestClockGetRequest() .testClockId("b33a6eda-5e97-5d64-244a-a9274110151c"); Response testClockGetResponse = client() .sandboxTransferTestClockGet(request) .execute(); TestClock testClock = testClockGetResponse.body().getTestClock(); ``` ```ruby request = Plaid::SandboxTransferTestClockGetRequest.new( { test_clock_id: 'b33a6eda-5e97-5d64-244a-a9274110151c' } ) response = client.sandbox_transfer_test_clock_get(request) test_clock = response.test_clock ``` ```go request := plaid.NewSandboxTransferTestClockGetRequest("b33a6eda-5e97-5d64-244a-a9274110151c") resp, _, err := client.PlaidApi.SandboxTransferTestClockGet(ctx).SandboxTransferTestClockGetRequest(*request).Execute() if err != nil { plaidErr, _ := plaid.ToPlaidError(err) fmt.Println(plaidErr.ErrorMessage) } testClock, ok := resp.GetTestClock() ``` #### Response fields  object Defines the test clock for a transfer. string Plaid's unique identifier for a test clock. This field is only populated in the Sandbox environment, and only if a `test_clock_id` was included in the `/transfer/recurring/create` request. For more details, see [Simulating recurring transfers](https://plaid.com/docs/transfer/sandbox/index.html.md#simulating-recurring-transfers) . string The virtual timestamp on the test clock. This will be of the form `2006-01-02T15:04:05Z`. Format: `date-time` string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "test_clock": { "test_clock_id": "b33a6eda-5e97-5d64-244a-a9274110151c", "virtual_time": "2006-01-02T15:04:05Z" }, "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/transfer/test\_clock/list  #### List test clocks  Use the [/sandbox/transfer/test\_clock/list](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransfertest_clocklist) 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. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. string The start virtual timestamp of test clocks to return. This should be in RFC 3339 format (i.e. `2019-12-06T22:35:49Z`) Format: `date-time` string The end virtual timestamp of test clocks to return. This should be in RFC 3339 format (i.e. `2019-12-06T22:35:49Z`) Format: `date-time` integer The maximum number of test clocks to return. Minimum: `1` Maximum: `25` Default: `25` integer The number of test clocks to skip before returning results. Default: `0` Minimum: `0` ```bash curl -X POST https://sandbox.plaid.com/sandbox/transfer/test_clock/list \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "count": 2 }' ``` ```node const request: SandboxTransferTestClockListRequest = { count: 2, }; try { const response = await plaidClient.sandboxTransferTestClockList(request); const test_clocks = response.data.test_clocks; } catch (error) { // handle error } ``` ```python request = SandboxTransferTestClockListRequest( count=2 ) response = client.sandbox_transfer_test_clock_list(request) test_clocks = response['test_clocks'] ``` ```java SandboxTransferTestClockListRequest request = new SandboxTransferTestClockListRequest() .count(1); Response testClockListResponse = client() .sandboxTransferTestClockList(request) .execute(); List testClocks = testClockListResponse.body().getTestClocks(); ``` ```ruby request = Plaid::SandboxTransferTestClockListRequest.new( { count: 2 } ) response = client.sandbox_transfer_test_clock_list(request) test_clocks = response.test_clocks ``` ```go request := plaid.NewSandboxTransferTestClockListRequest() request.SetCount(2) resp, _, err := client.PlaidApi.SandboxTransferTestClockList(ctx).SandboxTransferTestClockListRequest(*request).Execute() if err != nil { plaidErr, _ := plaid.ToPlaidError(err) fmt.Println(plaidErr.ErrorMessage) } testClocks, ok := resp.GetTestClocks() ``` #### Response fields  \[object\] string Plaid's unique identifier for a test clock. This field is only populated in the Sandbox environment, and only if a `test_clock_id` was included in the `/transfer/recurring/create` request. For more details, see [Simulating recurring transfers](https://plaid.com/docs/transfer/sandbox/index.html.md#simulating-recurring-transfers) . string The virtual timestamp on the test clock. This will be of the form `2006-01-02T15:04:05Z`. Format: `date-time` string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "test_clocks": [ { "test_clock_id": "b33a6eda-5e97-5d64-244a-a9274110151c", "virtual_time": "2006-01-02T15:04:05Z" }, { "test_clock_id": "a33a6eda-5e97-5d64-244a-a9274110152d", "virtual_time": "2006-02-02T15:04:05Z" } ], "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/income/fire\_webhook  #### Manually fire an Income webhook  Use the [/sandbox/income/fire\_webhook](https://plaid.com/docs/api/sandbox/index.html.md#sandboxincomefire_webhook) endpoint to manually trigger a Payroll or Document Income webhook in the Sandbox environment. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The Item ID associated with the verification. string The Plaid `user_id` of the User associated with this webhook, warning, or error. required, string The URL to which the webhook should be sent. Format: `url` string `VERIFICATION_STATUS_PROCESSING_COMPLETE`: The income verification status processing has completed. If the user uploaded multiple documents, this webhook will fire when all documents have finished processing. Call the `/income/verification/paystubs/get` endpoint and check the document metadata to see which documents were successfully parsed. `VERIFICATION_STATUS_PROCESSING_FAILED`: A failure occurred when attempting to process the verification documentation. `VERIFICATION_STATUS_PENDING_APPROVAL`: (deprecated) The income verification has been sent to the user for review. Possible values: `VERIFICATION_STATUS_PROCESSING_COMPLETE`, `VERIFICATION_STATUS_PROCESSING_FAILED`, `VERIFICATION_STATUS_PENDING_APPROVAL` required, string The webhook codes that can be fired by this test endpoint. Possible values: `INCOME_VERIFICATION`, `INCOME_VERIFICATION_RISK_SIGNALS` ```bash curl -X POST https://sandbox.plaid.com/sandbox/income/fire_webhook \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "item_id": "Rn3637v1adCNj5Dl1LG6idQBzqBLwRcRZLbgM", "webhook": "https://webhook.com/", "webhook_code": "INCOME_VERIFICATION", "verification_status": "VERIFICATION_STATUS_PROCESSING_COMPLETE" }' ``` ```node const request: SandboxIncomeFireWebhookRequest = { item_id: 'Rn3637v1adCNj5Dl1LG6idQBzqBLwRcRZLbgM', webhook: 'https://webhook.com/', webhook_code: 'INCOME_VERIFICATION', verification_status: 'VERIFICATION_STATUS_PROCESSING_COMPLETE', }; try { const response = await plaidClient.sandboxIncomeFireWebhook(request); // empty response upon success } catch (error) { // handle error } ``` ```python request = SandboxIncomeFireWebhookRequest( item_id='Rn3637v1adCNj5Dl1LG6idQBzqBLwRcRZLbgM', webhook='https://www.webhook.com', webhook_code='INCOME_VERIFICATION', verification_status='VERIFICATION_STATUS_PROCESSING_COMPLETE' ) response = client.sandbox_income_fire_webhook(request) # empty response upon success ``` ```java SandboxIncomeFireWebhookRequest request = new SandboxIncomeFireWebhookRequest() .itemId("Rn3637v1adCNj5Dl1LG6idQBzqBLwRcRZLbgM") .webhook("https://www.webhook.com") .webhookCode(SandboxIncomeWebhookFireRequestWebhookCode.INCOME_VERIFICATION) .verificationStatus("VERIFICATION_STATUS_PROCESSING_COMPLETE"); Response response = client() .sandboxIncomeFireWebhook(request) .execute(); ``` ```ruby request = Plaid::SandboxIncomeFireWebhookRequest.new( { item_id: 'Rn3637v1adCNj5Dl1LG6idQBzqBLwRcRZLbgM', webhook: 'https://www.webhook.com', webhook_code: 'INCOME_VERIFICATION', verification_status: 'VERIFICATION_STATUS_PROCESSING_COMPLETE' } ) response = client.sandbox_income_fire_webhook(request) # empty response upon success ``` ```go request := plaid.NewSandboxIncomeFireWebhookRequest("Rn3637v1adCNj5Dl1LG6idQBzqBLwRcRZLbgM", "https://www.webhook.com", plaid.SANDBOXINCOMEWEBHOOKFIREREQUESTWEBHOOKCODE_INCOME_VERIFICATION) request.SetVerificationStatus("VERIFICATION_STATUS_PROCESSING_COMPLETE") incomeFireWebhookResp, _, err := client.PlaidApi.SandboxIncomeFireWebhook(ctx).SandboxIncomeFireWebhookRequest( *request, ).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/cra/cashflow\_updates/update  #### Trigger an update for Cash Flow Updates  Use the [/sandbox/cra/cashflow\_updates/update](https://plaid.com/docs/api/sandbox/index.html.md#sandboxcracashflow_updatesupdate) endpoint to manually trigger an update for Cash Flow Updates (Monitoring) in the Sandbox environment. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. string The user token associated with the user for which data is being requested. This field is used only by customers with pre-existing integrations that already use the `user_token` field. All other customers should use the `user_id` instead. For more details, see [New User APIs](https://plaid.com/docs/api/users/user-apis/index.html.md) . \[string\] Webhook codes corresponding to the Cash Flow Updates events to be simulated. Possible values: `LARGE_DEPOSIT_DETECTED`, `LOW_BALANCE_DETECTED`, `NEW_LOAN_PAYMENT_DETECTED`, `NSF_OVERDRAFT_DETECTED` string A unique user identifier, created by `/user/create`. Integrations that began using `/user/create` after December 10, 2025 use this field to identify a user instead of the `user_token`. For more details, see [New User APIs](https://plaid.com/docs/api/users/user-apis/index.html.md) . ```bash curl -X POST https://sandbox.plaid.com/sandbox/cra/cashflow_updates/update \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "user_id": "usr_9nSp2KuZ2x4JDw", "webhook_codes": ["LARGE_DEPOSIT_DETECTED", "LOW_BALANCE_DETECTED"] }' ``` ```node const request: SandboxCraCashflowUpdatesUpdateRequest = { user_id: 'usr_9nSp2KuZ2x4JDw', webhook_codes: ['LARGE_DEPOSIT_DETECTED', 'LOW_BALANCE_DETECTED'], }; try { const response = await plaidClient.sandboxCraCashflowUpdatesUpdate(request); // empty response upon success } catch (error) { // handle error } ``` ```python request = SandboxCraCashflowUpdatesUpdateRequest( user_id='usr_9nSp2KuZ2x4JDw', webhook_codes=['LARGE_DEPOSIT_DETECTED', 'LOW_BALANCE_DETECTED'] ) response = client.sandbox_cra_cashflow_updates_update(request) # empty response upon success ``` ```java SandboxCraCashflowUpdatesUpdateRequest request = new SandboxCraCashflowUpdatesUpdateRequest() .userId("usr_9nSp2KuZ2x4JDw") .webhookCodes(Arrays.asList("LARGE_DEPOSIT_DETECTED", "LOW_BALANCE_DETECTED")); Response response = client() .sandboxCraCashflowUpdatesUpdate(request) .execute(); ``` ```ruby request = Plaid::SandboxCraCashflowUpdatesUpdateRequest.new( { user_id: 'usr_9nSp2KuZ2x4JDw', webhook_codes: ['LARGE_DEPOSIT_DETECTED', 'LOW_BALANCE_DETECTED'] } ) response = client.sandbox_cra_cashflow_updates_update(request) # empty response upon success ``` ```go request := plaid.NewSandboxCraCashflowUpdatesUpdateRequest() request.SetUserId("usr_9nSp2KuZ2x4JDw") request.SetWebhookCodes([]string{"LARGE_DEPOSIT_DETECTED", "LOW_BALANCE_DETECTED"}) craCashflowUpdatesResp, _, err := client.PlaidApi.SandboxCraCashflowUpdatesUpdate(ctx).SandboxCraCashflowUpdatesUpdateRequest( *request, ).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "mdqfuVxeoza6mhu" } ``` \=\*=\*=\*= #### /sandbox/payment/simulate  #### Simulate a payment event in Sandbox  Use the [/sandbox/payment/simulate](https://plaid.com/docs/api/sandbox/index.html.md#sandboxpaymentsimulate) endpoint to simulate various payment events in the Sandbox environment. This endpoint will trigger the corresponding payment status webhook. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The ID of the payment to simulate required, string The webhook url to use for any payment events triggered by the simulated status change. required, string The status to set the payment to. Valid statuses include: * `PAYMENT_STATUS_INITIATED` * `PAYMENT_STATUS_INSUFFICIENT_FUNDS` * `PAYMENT_STATUS_FAILED` * `PAYMENT_STATUS_EXECUTED` * `PAYMENT_STATUS_SETTLED` * `PAYMENT_STATUS_CANCELLED` * `PAYMENT_STATUS_REJECTED` ```bash curl -X POST https://sandbox.plaid.com/sandbox/payment/simulate \ -H 'Content-Type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "payment_id": "payment-id-sandbox-feca8a7a-5591-4aef-9297-f3062bb735d3", "webhook": "https://webhook.com/", "status": "PAYMENT_STATUS_INITIATED" }' ``` ```node const request: SandboxPaymentSimulateRequest = { payment_id: 'payment-id-sandbox-feca8a7a-5591-4aef-9297-f3062bb735d3', webhook: 'https://webhook.com/', status: "PAYMENT_STATUS_INITIATED" }; try { const response = await plaidClient.sandboxPaymentSimulate(request); } catch (error) { // handle error } ``` ```python request = SandboxPaymentSimulateRequest( payment_id='payment-id-sandbox-feca8a7a-5591-4aef-9297-f3062bb735d3', webhook='https://webhook.com/', status="PAYMENT_STATUS_INITIATED" ) response = client.sandbox_payment_simulate(request) ``` ```java SandboxPaymentSimulateRequest request = new SandboxPaymentSimulateRequest() .paymentId("payment-id-sandbox-feca8a7a-5591-4aef-9297-f3062bb735d3") .webhook("https://webhook.com/") .status("PAYMENT_STATUS_INITIATED"); Response response = client() .sandboxPaymentSimulate(request) .execute(); ``` ```ruby request = Plaid::SandboxPaymentSimulateRequest.new({ payment_id: "payment-id-sandbox-feca8a7a-5591-4aef-9297-f3062bb735d3", webhook: "https://webhook.com/", status: "PAYMENT_STATUS_INITIATED" }) response = client.sandbox_payment_simulate(request) ``` ```go request := plaid.NewSandboxPaymentSimulateRequest("payment-id-sandbox-feca8a7a-5591-4aef-9297-f3062bb735d3", "https://webhook.com/", "PAYMENT_STATUS_INITIATED") response, _, err := client.PlaidApi.SandboxPaymentSimulate(ctx).SandboxPaymentSimulateRequest(*request).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. string The status of the payment. Core lifecycle statuses: **`PAYMENT_STATUS_INPUT_NEEDED`**: Transitional. The payment is awaiting user input to continue processing. It may re-enter this state if additional input is required. **`PAYMENT_STATUS_AUTHORISING`:** Transitional. The payment is being authorised by the financial institution. It will automatically move on once authorisation completes. **`PAYMENT_STATUS_INITIATED`:** The payment has been authorised and accepted by the financial institution. In many EU markets, `PAYMENT_STATUS_EXECUTED` is not supported, and a payment will remain in `PAYMENT_STATUS_INITIATED` until the funds settle, making this a terminal success state in those cases. A payment in `PAYMENT_STATUS_INITIATED` should be treated as a successfully submitted payment; do not gate downstream processing on reaching `PAYMENT_STATUS_EXECUTED`. For a full explanation of payment statuses and how to handle each, see the [Payment Status guide](https://plaid.com/docs/payment-initiation/payment-status/index.html.md) . **`PAYMENT_STATUS_EXECUTED`: Terminal.** The funds have left the payer's account and the payment is en route to settlement. Note that this status does not confirm that funds have arrived in the recipient's account; do not use it as proof of fund receipt. Support is more common in the UK than in the EU; where unsupported, a successful payment remains in `PAYMENT_STATUS_INITIATED` before settling. When using Plaid Virtual Accounts, `PAYMENT_STATUS_EXECUTED` is not terminal -- the payment will continue to `PAYMENT_STATUS_SETTLED` once funds are available. **`PAYMENT_STATUS_SETTLED`: Terminal.** The funds are available in the recipient's account. Only available to customers using [Plaid Virtual Accounts](https://plaid.com/docs/payment-initiation/virtual-accounts/index.html.md) . Failure statuses: **`PAYMENT_STATUS_INSUFFICIENT_FUNDS`: Terminal.** The payment failed due to insufficient funds. No further retries will succeed until the payer's balance is replenished. **`PAYMENT_STATUS_FAILED`: Terminal (retryable).** The payment could not be initiated due to a system error or outage. Retry once the root cause is resolved. **`PAYMENT_STATUS_BLOCKED`: Terminal (retryable).** The payment was blocked by Plaid (e.g., flagged as risky). Resolve any compliance or risk issues and retry. **`PAYMENT_STATUS_REJECTED`: Terminal.** The payment was rejected by the financial institution. No automatic retry is possible. **`PAYMENT_STATUS_CANCELLED`: Terminal.** The end user cancelled the payment during authorisation. Standing-order statuses: **`PAYMENT_STATUS_ESTABLISHED`: Terminal.** A recurring/standing order has been successfully created. Deprecated (to be removed in a future release): `PAYMENT_STATUS_UNKNOWN`: The payment status is unknown. `PAYMENT_STATUS_PROCESSING`: The payment is currently being processed. `PAYMENT_STATUS_COMPLETED`: Indicates that the standing order has been successfully established. Possible values: `PAYMENT_STATUS_INPUT_NEEDED`, `PAYMENT_STATUS_PROCESSING`, `PAYMENT_STATUS_INITIATED`, `PAYMENT_STATUS_COMPLETED`, `PAYMENT_STATUS_INSUFFICIENT_FUNDS`, `PAYMENT_STATUS_FAILED`, `PAYMENT_STATUS_BLOCKED`, `PAYMENT_STATUS_UNKNOWN`, `PAYMENT_STATUS_EXECUTED`, `PAYMENT_STATUS_SETTLED`, `PAYMENT_STATUS_AUTHORISING`, `PAYMENT_STATUS_CANCELLED`, `PAYMENT_STATUS_ESTABLISHED`, `PAYMENT_STATUS_REJECTED` string The status of the payment. Core lifecycle statuses: **`PAYMENT_STATUS_INPUT_NEEDED`**: Transitional. The payment is awaiting user input to continue processing. It may re-enter this state if additional input is required. **`PAYMENT_STATUS_AUTHORISING`:** Transitional. The payment is being authorised by the financial institution. It will automatically move on once authorisation completes. **`PAYMENT_STATUS_INITIATED`:** The payment has been authorised and accepted by the financial institution. In many EU markets, `PAYMENT_STATUS_EXECUTED` is not supported, and a payment will remain in `PAYMENT_STATUS_INITIATED` until the funds settle, making this a terminal success state in those cases. A payment in `PAYMENT_STATUS_INITIATED` should be treated as a successfully submitted payment; do not gate downstream processing on reaching `PAYMENT_STATUS_EXECUTED`. For a full explanation of payment statuses and how to handle each, see the [Payment Status guide](https://plaid.com/docs/payment-initiation/payment-status/index.html.md) . **`PAYMENT_STATUS_EXECUTED`: Terminal.** The funds have left the payer's account and the payment is en route to settlement. Note that this status does not confirm that funds have arrived in the recipient's account; do not use it as proof of fund receipt. Support is more common in the UK than in the EU; where unsupported, a successful payment remains in `PAYMENT_STATUS_INITIATED` before settling. When using Plaid Virtual Accounts, `PAYMENT_STATUS_EXECUTED` is not terminal -- the payment will continue to `PAYMENT_STATUS_SETTLED` once funds are available. **`PAYMENT_STATUS_SETTLED`: Terminal.** The funds are available in the recipient's account. Only available to customers using [Plaid Virtual Accounts](https://plaid.com/docs/payment-initiation/virtual-accounts/index.html.md) . Failure statuses: **`PAYMENT_STATUS_INSUFFICIENT_FUNDS`: Terminal.** The payment failed due to insufficient funds. No further retries will succeed until the payer's balance is replenished. **`PAYMENT_STATUS_FAILED`: Terminal (retryable).** The payment could not be initiated due to a system error or outage. Retry once the root cause is resolved. **`PAYMENT_STATUS_BLOCKED`: Terminal (retryable).** The payment was blocked by Plaid (e.g., flagged as risky). Resolve any compliance or risk issues and retry. **`PAYMENT_STATUS_REJECTED`: Terminal.** The payment was rejected by the financial institution. No automatic retry is possible. **`PAYMENT_STATUS_CANCELLED`: Terminal.** The end user cancelled the payment during authorisation. Standing-order statuses: **`PAYMENT_STATUS_ESTABLISHED`: Terminal.** A recurring/standing order has been successfully created. Deprecated (to be removed in a future release): `PAYMENT_STATUS_UNKNOWN`: The payment status is unknown. `PAYMENT_STATUS_PROCESSING`: The payment is currently being processed. `PAYMENT_STATUS_COMPLETED`: Indicates that the standing order has been successfully established. Possible values: `PAYMENT_STATUS_INPUT_NEEDED`, `PAYMENT_STATUS_PROCESSING`, `PAYMENT_STATUS_INITIATED`, `PAYMENT_STATUS_COMPLETED`, `PAYMENT_STATUS_INSUFFICIENT_FUNDS`, `PAYMENT_STATUS_FAILED`, `PAYMENT_STATUS_BLOCKED`, `PAYMENT_STATUS_UNKNOWN`, `PAYMENT_STATUS_EXECUTED`, `PAYMENT_STATUS_SETTLED`, `PAYMENT_STATUS_AUTHORISING`, `PAYMENT_STATUS_CANCELLED`, `PAYMENT_STATUS_ESTABLISHED`, `PAYMENT_STATUS_REJECTED` Response Object ```json { "request_id": "m8MDnv9okwxFNBV", "old_status": "PAYMENT_STATUS_INPUT_NEEDED", "new_status": "PAYMENT_STATUS_INITIATED" } ``` \=\*=\*=\*= #### /sandbox/transactions/create  #### Create sandbox transactions  Use the [/sandbox/transactions/create](https://plaid.com/docs/api/sandbox/index.html.md#sandboxtransactionscreate) 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](https://plaid.com/docs/api/products/transactions/index.html.md#transactionsget) and [/transactions/sync](https://plaid.com/docs/api/products/transactions/index.html.md#transactionssync) endpoints. Custom transactions are only applied to the depository account. Support for per-account targeting may be added in the future. #### Request fields  string Your Plaid API `client_id`. The `client_id` is required and may be provided either in the `PLAID-CLIENT-ID` header or as part of a request body. string Your Plaid API `secret`. The `secret` is required and may be provided either in the `PLAID-SECRET` header or as part of a request body. required, string The access token associated with the Item for which data is being requested. required, \[object\] List of transactions to be added required, string The date of the transaction, in [ISO 8601](https://wikipedia.org/wiki/ISO_8601) (YYYY-MM-DD) format. Transaction date must be the present date or a date up to 14 days in the past. Future dates are not allowed. Format: `date` required, string The date the transaction posted, in [ISO 8601](https://wikipedia.org/wiki/ISO_8601) (YYYY-MM-DD) format. Posted date must be the present date or a date up to 14 days in the past. Future dates are not allowed. Format: `date` required, number The transaction amount. Can be negative. Format: `double` required, string The transaction description. string The ISO-4217 format currency code for the transaction. Defaults to USD. ```bash curl -X POST https://sandbox.plaid.com/sandbox/transactions/create \ -H 'content-type: application/json' \ -d '{ "client_id": "${PLAID_CLIENT_ID}", "secret": "${PLAID_SECRET}", "access_token": String, "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" } ] }' ``` ```node 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.sandboxTransactionsCreate(request); } catch (error) { // handle error } ``` ```ruby request = Plaid::SandboxTransactionsCreateRequest.new({ access_token: access_token, 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' } ] }) response = client.sandbox_transactions_create(request) ``` ```java List transactions = Arrays.asList( new CustomSandboxTransaction() .amount(100.50) .datePosted("2025-06-08") .dateTransacted("2025-06-08") .description("Tim Hortons"), new CustomSandboxTransaction() .amount(-25.75) .datePosted("2025-06-08") .dateTransacted("2025-06-08") .description("BestBuy") .isoCurrencyCode("CAD") ); SandboxTransactionsCreateRequest request = new SandboxTransactionsCreateRequest() .accessToken(accessToken) .transactions(transactions); Response response = client() .sandboxTransactionsCreate(request) .execute(); ``` ```python request = SandboxTransactionsCreateRequest( access_token=access_token, 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' } ] ) response = client.sandbox_transactions_create(request) ``` ```go transactions := []plaid.CustomSandboxTransaction{ { Amount: 100.50, DatePosted: "2025-06-08", DateTransacted: "2025-06-08", Description: "Tim Hortons", }, { Amount: -25.75, DatePosted: "2025-06-08", DateTransacted: "2025-06-08", Description: "BestBuy", IsoCurrencyCode: "CAD", }, } request := plaid.NewSandboxTransactionsCreateRequest(accessToken, transactions) response, _, err := client.PlaidApi.SandboxTransactionsCreate(ctx).SandboxTransactionsCreateRequest(*request).Execute() ``` #### Response fields  string A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive. Response Object ```json { "request_id": "m8MDnv9okwxFNBV" } ```