Plaid API

https://plaid.com/docs/api/
Admin
The Plaid API provides a comprehensive set of endpoints for developers to integrate financial...
Tokens:706,534
Snippets:5,581
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Processor Account Get in Go

Source: https://plaid.com/docs/api/processor-partners

Example request to the /processor/account/get endpoint using the Go client.

```go
ProcessorAccountGetResp, _, err := client.PlaidApi.ProcessorAccountGet(ctx).ProcessorAccountGetRequest(
*plaid.NewProcessorAccountGetRequest(processorToken),
).Execute()
```

--------------------------------

### Create Payment Initiation in Go

Source: https://plaid.com/docs/api/products/payment-initiation

Example of creating a payment initiation request with a schedule using the Go client library.

```go
request := plaid.NewPaymentInitiationPaymentCreateRequest(
  recipientID,
  "TestPayment",
  *plaid.NewPaymentAmount("GBP", 100.0),
)
request.SetSchedule(*plaid.NewExternalPaymentScheduleRequest(
  plaid.PAYMENTSCHEDULEINTERVAL_MONTHLY,
  1,
  "2020-01-01",
))
response, _, err := client.PlaidApi.PaymentInitiationPaymentCreate(ctx).PaymentInitiationPaymentCreateRequest(*request).Execute()
paymentID := response.GetPaymentId()
```

--------------------------------

### Processor Identity Get cURL Request

Source: https://plaid.com/docs/api/processor-partners

Example of calling the /processor/identity/get endpoint using cURL.

```bash
curl -X POST https://sandbox.plaid.com/processor/identity/get \
-H 'Content-Type: application/json' \
-d '{
  "client_id": "${PLAID_CLIENT_ID}",
  "secret": "${PLAID_SECRET}",
  "processor_token": String
}'
```

--------------------------------

### Create Payment Initiation in Java

Source: https://plaid.com/docs/api/products/payment-initiation

Example of creating a payment initiation request using the Java client library.

```java
PaymentAmount amount = new PaymentAmount()
  .currency(PaymentAmountCurrency.GBP)
  .value(999.99);
PaymentInitiationPaymentCreateRequest request = new PaymentInitiationPaymentCreateRequest()
  .recipientId(recipientId)
  .reference("reference")
  .amount(amount);
Response response = client
  .paymentInitiationPaymentCreate(request)
  .execute();
```

--------------------------------

### Processor Account Get in Node.js

Source: https://plaid.com/docs/api/processor-partners

Example request to the /processor/account/get endpoint using the Node.js client.

```node
try {
  const request: ProcessorAccountGetRequest = {
    processor_token: processorToken,
  };
  const response = await plaidClient.processorAccountGet(request);
} catch (error) {
  // handle error
}
```

--------------------------------

### Create a user with Go

Source: https://plaid.com/docs/api/products/income

Example of creating a user using the Plaid Go client.

```go
request := plaid.NewUserCreateRequest(
  "c0e2c4ee-b763-4af5-cfe9-46a46bce883d",
)

response, _, err := client.PlaidApi.UserCreate(ctx).UserCreateRequest(*request).Execute()
```

--------------------------------

### Create a platform originator in Go

Source: https://plaid.com/docs/api/products/transfer/platform-payments

Configure the TOS metadata and request objects, then execute the API call using the Plaid client.

```go
tosMetadata := plaid.TransferPlatformTOSAcceptanceMetadata{
  AgreementAccepted:   true,
  OriginatorIpAddress: "192.0.2.42",
  AgreementAcceptedAt: time.Date(2017, 9, 14, 14, 42, 19, 350000000, time.UTC),
}

request := plaid.NewTransferPlatformOriginatorCreateRequest(
  "6a65dh3d1h0d1027121ak184",
  tosMetadata,
  time.Date(2024, 7, 29, 20, 22, 21, 0, time.UTC),
)
request.SetWebhook("https://webhook.com/webhook")

response, _, err := client.PlaidApi.TransferPlatformOriginatorCreate(ctx).
  TransferPlatformOriginatorCreateRequest(*request).
  Execute()
```

--------------------------------

### Processor Account Get in Python

Source: https://plaid.com/docs/api/processor-partners

Example request to the /processor/account/get endpoint using the Python client.

```python
request = ProcessorAccountGetRequest(
processor_token=processor_token,
)
response = client.processor_account_get(request)
```

--------------------------------

### Processor Account Get in Ruby

Source: https://plaid.com/docs/api/processor-partners

Example request to the /processor/account/get endpoint using the Ruby client.

```ruby
processor_account_get_request = Plaid::ProcessorAccountGetRequest.new(
{
  processor_token: processor_token,
}
)
response = client.processor_account_get(processor_account_get_request)
```

--------------------------------

### Create Payment Initiation in Python

Source: https://plaid.com/docs/api/products/payment-initiation

Example of creating a payment initiation request using the Python client library.

```python
request = PaymentInitiationPaymentCreateRequest(
    recipient_id=recipient_id,
    reference='TestPayment',
    amount=PaymentAmount(
        currency=PaymentAmountCurrency('GBP'),
        value=100.00
    )
)
response = client.payment_initiation_payment_create(request)
payment_id = response["payment_id"]
status = response["status"]
```

--------------------------------

### Processor Account Get in Java

Source: https://plaid.com/docs/api/processor-partners

Example request to the /processor/account/get endpoint using the Java client.

```java
ProcessorAccountGetRequest request = new ProcessorAccountGetRequest()
.processorToken(processorToken);

Response response = client()
.processorAccountGet(request)
.execute();
```

--------------------------------

### Create Payment Initiation in Ruby

Source: https://plaid.com/docs/api/products/payment-initiation

Example of creating a payment initiation request using the Ruby client library.

```ruby
request = Plaid::PaymentInitiationPaymentCreateRequest.new(
  {
    recipient_id: recipient_id,
    reference: "testpayment",
    amount: {
      value: 100.00,
      currency: "GBP"
    }
  }
)
response = client.payment_initiation_payment_create(request)
payment_id = response.payment_id
status = response.status
```

--------------------------------

### Processor Account Get via cURL

Source: https://plaid.com/docs/api/processor-partners

Example request to the /processor/account/get endpoint using cURL.

```bash
curl \
-H 'Content-Type: application/json' \
-d '{
"client_id": "${PLAID_CLIENT_ID}",
"secret": "${PLAID_SECRET}",
"processor_token": "${PROCESSOR_TOKEN}"
}' \
-X POST \
https://sandbox.plaid.com/processor/account/get
```

--------------------------------

### Create a user with Java

Source: https://plaid.com/docs/api/products/income

Example of creating a user using the Plaid Java client.

```java
UserCreateRequest request = new UserCreateRequest()
  .clientUserId("c0e2c4ee-b763-4af5-cfe9-46a46bce883d");

Response response = client
  .userCreate(request, null)
  .execute();
```

--------------------------------

### Processor Identity Get Java Request

Source: https://plaid.com/docs/api/processor-partners

Example of calling the /processor/identity/get endpoint using the Java client.

```java
ProcessorIdentityGetRequest request = new ProcessorIdentityGetRequest()
  .processorToken(processorToken);
Response response = client()
  .processorIdentityGet(request)
  .execute();
```

--------------------------------

### Create a user with Python

Source: https://plaid.com/docs/api/products/income

Example of creating a user using the Plaid Python client.

```python
request = UserCreateRequest(
  client_user_id='c0e2c4ee-b763-4af5-cfe9-46a46bce883d'
)

response = client.user_create(request)
```

--------------------------------

### Processor Identity Get Python Request

Source: https://plaid.com/docs/api/processor-partners

Example of calling the /processor/identity/get endpoint using the Python client.

```python
request = ProcessorIdentityGetRequest(
    processor_token=processor_token,
)
response = client.processor_identity_get(request)
```

--------------------------------

### Create Payment Initiation Consent in Go

Source: https://plaid.com/docs/api/products/payment-initiation

Uses the Plaid Go client to construct constraints and execute a payment initiation consent creation request.

```go
constraints := plaid.NewPaymentInitiationConsentConstraints(
  *plaid.NewPaymentConsentMaxPaymentAmount("GBP", 15),
  []plaid.PaymentConsentPeriodicAmount{
    *plaid.NewPaymentConsentPeriodicAmount(
      *plaid.NewPaymentConsentPeriodicAmountAmount("GBP", 40),
      plaid.PAYMENTCONSENTPERIODICINTERVAL_MONTH,
      plaid.PAYMENTCONSENTPERIODICALIGNMENT_CALENDAR,
    ),
  },
)
consentValidDateTime := plaid.NewPaymentConsentValidDateTime()
validUntil := time.Date(2024, time.December, 31, 23, 59, 59, 0, time.UTC)
consentValidDateTime.SetTo(validUntil)
constraints.SetValidDateTime(*consentValidDateTime)

request := plaid.NewPaymentInitiationConsentCreateRequest(
  recipientID,
  "TestPaymentConsent",
  *constraints,
)

request.SetType(plaid.PAYMENTINITIATIONCONSENTTYPE_COMMERCIAL)

response, _, err := client.PlaidApi.PaymentInitiationConsentCreate(ctx).PaymentInitiationConsentCreateRequest(*request).Execute()
consentID := response.GetConsentId()
```

--------------------------------

### Create Payment Initiation in Node.js

Source: https://plaid.com/docs/api/products/payment-initiation

Example of creating a payment initiation request using the Node.js client library.

```node
const request: PaymentInitiationPaymentCreateRequest = {
  recipient_id: recipientID,
  reference: 'TestPayment',
  amount: {
    currency: 'GBP',
    value: 100.00,
  },
};
try {
  const response = await plaidClient.paymentInitiationPaymentCreate(request);
  const paymentID = response.data.payment_id;
  const status = response.data.status;
} catch (error) {
  // handle error
}
```

--------------------------------

### Processor Identity Get Ruby Request

Source: https://plaid.com/docs/api/processor-partners

Example of calling the /processor/identity/get endpoint using the Ruby client.

```ruby
request = Plaid::ProcessorIdentityGetRequest.new({ processor_token: processor_token })
response = client.processor_identity_get(request)
```

--------------------------------

### Processor Identity Get Go Request

Source: https://plaid.com/docs/api/processor-partners

Example of calling the /processor/identity/get endpoint using the Go client.

```go
request := plaid.NewProcessorIdentityGetRequest(processorToken)
response, _, err := client.PlaidApi.ProcessorIdentityGet(ctx).ProcessorIdentityGetRequest(
  *request,
).Execute()
```

--------------------------------

### Create a user with Ruby

Source: https://plaid.com/docs/api/products/income

Example of creating a user using the Plaid Ruby client.

```ruby
request = Plaid::UserCreateRequest.new(
  {
    client_user_id: 'c0e2c4ee-b763-4af5-cfe9-46a46bce883d'
  }
)

response = client.user_create(request)
```

--------------------------------

### Processor Identity Get Node.js Request

Source: https://plaid.com/docs/api/processor-partners

Example of calling the /processor/identity/get endpoint using the Node.js client.

```node
const request: ProcessorIdentityGetRequest = {
  processor_token: processorToken,
};
const response = await plaidClient.processorIdentityGet(request);
```

--------------------------------

### List Bank Transfer Events in Go

Source: https://plaid.com/docs/api/products/auth

Example of using the Go client to initialize a request and execute the bank transfer event list call.

```go
request := plaid.NewBankTransferEventListRequest()
response, _, err := client.PlaidApi.BankTransferEventList(ctx).BankTransferEventListRequest(*request).Execute()
```

--------------------------------

### Get Partner Insights Report in Go

Source: https://plaid.com/docs/api/products/check

Example request to the Partner Insights endpoint using the Go client.

```go
request := plaid.NewCraCheckReportPartnerInsightsGetRequest()
request.SetUserId("usr_9nSp2KuZ2x4JDw")

response, _, err := client.PlaidApi.
  CraCheckReportPartnerInsightsGet(ctx).
  CraCheckReportPartnerInsightsGetRequest(*request).
  Execute()
```

--------------------------------

### Create Payment Initiation via cURL

Source: https://plaid.com/docs/api/products/payment-initiation

Example of creating a payment initiation request using a raw HTTP POST request.

```bash
curl -X POST https://sandbox.plaid.com/payment_initiation/payment/create \
-H 'Content-Type: application/json' \
-d '{
  "client_id": "${PLAID_CLIENT_ID}",
  "secret": "${PLAID_SECRET}",
  "recipient_id": String,
  "reference": String,
  "amount": Object,
  "schedule": Object
}'
```

--------------------------------

### Create an Asset Report in Python

Source: https://plaid.com/docs/api/products/assets

Example of initializing an AssetReportCreateRequest with access tokens, days requested, and optional user and webhook information.

```python
# access_tokens is a list of Item access tokens.
# Note that the assets product must be enabled for all Items.
# All fields on the options object are optional.
request = AssetReportCreateRequest(
    access_tokens=[access_token],
    days_requested=90,
    options=AssetReportCreateRequestOptions(
        webhook='https://www.example.com',
        client_report_id='123',
        user=AssetReportUser(
            client_user_id='7f57eb3d2a9j6480121fx361',
            first_name='Jane',
            middle_name='Leah',
            last_name='Doe',
            ssn='123-45-6789',
            phone_number='(555) 123-4567',
            email='jane.doe@example.com',
        )
    )
)
response = client.asset_report_create(request)
asset_report_id = response['asset_report_id']
asset_report_token = response['asset_report_token']
```

--------------------------------

### Get Partner Insights Report in Java

Source: https://plaid.com/docs/api/products/check

Example request to the Partner Insights endpoint using the Java client.

```java
CraCheckReportPartnerInsightsGetRequest request = new CraCheckReportPartnerInsightsGetRequest()
  .userId("usr_9nSp2KuZ2x4JDw");

Response response = client
  .craCheckReportPartnerInsightsGet(request)
  .execute();
```

--------------------------------

### Create Processor Token in Java

Source: https://plaid.com/docs/api/processors

Demonstrates initializing the Plaid client, exchanging a public token, and creating a Dwolla processor token.

```java
import com.plaid.client.model.ItemPublicTokenExchangeRequest;
import com.plaid.client.model.ItemPublicTokenExchangeResponse;
import com.plaid.client.model.ProcessorTokenCreateRequest;
import com.plaid.client.model.ProcessorTokenCreateResponse;

// Change sandbox to production when you're ready to go live!
HashMap apiKeys = new HashMap();
apiKeys.put("clientId", plaidClientId);
apiKeys.put("secret", plaidSecret);
apiKeys.put("plaidVersion", "2020-09-14");
apiClient = new ApiClient(apiKeys);
apiClient.setPlaidAdapter(ApiClient.Sandbox);

plaidClient = apiClient.createService(PlaidApi.class);

// Exchange the public token from Plaid Link for an access token.
ItemPublicTokenExchangeRequest request = new ItemPublicTokenExchangeRequest()
  .publicToken(publicToken);

Response exchangeResponse = client()
  .itemPublicTokenExchange(request)
  .execute();

// Create a processor token for a specific account id.
if (exchangeResponse.isSuccessful()) {
  String accessToken = exchangeResponse.body().getAccessToken();
  ProcessorTokenCreateRequest processorRequest = new ProcessorTokenCreateRequest()
    .accessToken(accessToken)
    .processor(ProcessorTokenCreateRequest.ProcessorEnum.DWOLLA)
    .accountId(accountID);

  Response dwollaResponse = client()
    .processorTokenCreate(processorRequest)
    .execute();

    if (dwollaResponse.isSuccessful()) {
      String dwollaProcessorToken = dwollaResponse.body().getProcessorToken();
    }
}
```

--------------------------------

### Get Partner Insights Report in Ruby

Source: https://plaid.com/docs/api/products/check

Example request to the Partner Insights endpoint using the Ruby client.

```ruby
request = Plaid::CraCheckReportPartnerInsightsGetRequest.new(
  {
    user_id: 'usr_9nSp2KuZ2x4JDw'
  }
)

response = client.cra_check_report_partner_insights_get(request)
```

--------------------------------

### Get Partner Insights Report in Python

Source: https://plaid.com/docs/api/products/check

Example request to the Partner Insights endpoint using the Python client.

```python
request = CraCheckReportPartnerInsightsGetRequest(
  user_id='usr_9nSp2KuZ2x4JDw'
)

response = client.cra_check_report_partner_insights_get(request)
```

--------------------------------

### Create a user with Node.js

Source: https://plaid.com/docs/api/products/income

Example of calling the userCreate method using the Plaid Node.js client.

```node
const request: UserCreateRequest = {
  client_user_id: 'c0e2c4ee-b763-4af5-cfe9-46a46bce883d',
};

try {
  const response = await client.userCreate(request);
} catch (error) {
  // handle error
}
```

--------------------------------

### Get Partner Insights Report in Node.js

Source: https://plaid.com/docs/api/products/check

Example request to the Partner Insights endpoint using the Node.js client.

```node
try {
  const response = await client.craCheckReportPartnerInsightsGet({
    user_id: 'usr_9nSp2KuZ2x4JDw',
  });
} catch (error) {
  // handle error
}
```

--------------------------------

### Create processor token with cURL

Source: https://plaid.com/docs/api/processors

This example shows how to exchange a public token for an access token, followed by creating a processor token for a specific account ID using the /processor/token/create endpoint.

```bash
# Exchange the public token from Plaid Link for an access token.
curl \
  -H 'Content-Type: application/json' \
  -d '{
    "client_id": "${PLAID_CLIENT_ID}",
    "secret": "${PLAID_SECRET}",
    "public_token": "${PUBLIC_TOKEN}"
  }' \
  -X POST \
  https://sandbox.plaid.com/item/public_token/exchange

# Create a processor token for a specific account id.
curl \
  -H 'Content-Type: application/json' \
  -d '{
    "client_id": "${PLAID_CLIENT_ID}",
    "secret": "${PLAID_SECRET}",
    "access_token": "${ACCESS_TOKEN}",
    "account_id": "${ACCOUNT_ID}",
    "processor": "dwolla"
  }' \
  -X POST \
  https://sandbox.plaid.com/processor/token/create
```

--------------------------------

### Retrieve Investment Transactions in Go

Source: https://plaid.com/docs/api/products/investments

Provides a simple example of initializing a request and executing it to retrieve investment transactions.

```go
request := plaid.NewInvestmentsTransactionsGetRequest(accessToken, startDateString, endDateString)
response, _, err := client.PlaidApi.InvestmentsTransactionsGet(ctx).InvestmentsTransactionsGetRequest(*request).Execute()
investmentTransactions := response.GetInvestmentTransactions()
```

--------------------------------

### Get Partner Insights Report via cURL

Source: https://plaid.com/docs/api/products/check

Example request to the Partner Insights endpoint using cURL.

```bash
curl -X POST https://sandbox.plaid.com/cra/check_report/partner_insights/get \
-H 'Content-Type: application/json' \
-d '{
  "client_id": "${PLAID_CLIENT_ID}",
  "secret": "${PLAID_SECRET}",
  "user_id": "usr_9nSp2KuZ2x4JDw"
}'
```

--------------------------------

### Get Payment Recipient Response Object

Source: https://plaid.com/docs/api/products/payment-initiation

Example JSON response containing full details of a payment recipient.

```json
{
  "recipient_id": "recipient-id-sandbox-9b6b4679-914b-445b-9450-efbdb80296f6",
  "name": "Wonder Wallet",
  "iban": "GB29NWBK60161331926819",
  "address": {
    "street": [
      "96 Guild Street",
      "9th Floor"
    ],
    "city": "London",
    "postal_code": "SE14 8JW",
    "country": "GB"
  },
  "request_id": "4zlKapIkTm8p5KM"
}
```

--------------------------------

### Create Entity Review in Go

Source: https://plaid.com/docs/api/products/monitor

Example of creating a watchlist screening entity review using the Go client.

```go
request := plaid.NewWatchlistScreeningEntityReviewCreateRequest(
  []string{"entscrhit_52xR9LKo77r1Np"},
  []string{},
  "entscr_52xR9LKo77r1Np",
)

response, _, err := client.PlaidApi.
  WatchlistScreeningEntityReviewCreate(ctx).
  WatchlistScreeningEntityReviewCreateRequest(*request).
  Execute()
```

--------------------------------

### Get a Beacon Duplicate Go Example

Source: https://plaid.com/docs/api/products/beacon

Retrieves a Beacon Duplicate record using the Go client library.

```go
request := plaid.NewBeaconDuplicateGetRequest("becdup_11111111111111")

response, _, err := client.PlaidApi.
    BeaconDuplicateGet(ctx).
    BeaconDuplicateGetRequest(*request).
    Execute()
```

--------------------------------

### Create a platform originator via cURL

Source: https://plaid.com/docs/api/products/transfer/platform-payments

Send a POST request to the sandbox environment with the required originator and TOS metadata in the JSON body.

```bash
curl -X POST https://sandbox.plaid.com/transfer/platform/originator/create \
 -H 'Content-Type: application/json' \
 -d '{
    "originator_client_id": "6a65dh3d1h0d1027121ak184",
      "tos_acceptance_metadata": {
      "agreement_accepted": true,
      "originator_ip_address": "192.0.2.42",
      "agreement_accepted_at": "2017-09-14T14:42:19.350Z"
    },
    "originator_reviewed_at": "2024-07-29T20:22:21Z",
    "webhook": "https://webhook.com/webhook"
 }'
```

--------------------------------

### Execute Wallet Transaction in Go

Source: https://plaid.com/docs/api/products/virtual-accounts

Example of creating a BACS counterparty and executing a wallet transaction using the Go SDK.

```go
counterpartyBACS := plaid.NewWalletTransactionCounterpartyBACS()
counterpartyBACS.SetAccount("12345678")
counterpartyBACS.SetSortCode("123456")

request := plaid.NewWalletTransactionExecuteRequest(
  "39fae5f2-b2b4-48b6-a363-5328995b2753",
  walletID,
  plaid.WalletTransactionCounterparty{
    Name: "Test",
    Numbers: plaid.WalletTransactionCounterpartyNumbers{
      Bacs: counterpartyBACS,
    },
  },
  plaid.WalletTransactionAmount{
    Value: 1.00,
    IsoCurrencyCode: plaid.WALLETISOCURRENCYCODE_GBP,
  },
  "TransactionABC123",
)
response, _, err := client.PlaidApi.WalletTransactionExecute(ctx).WalletTransactionExecuteRequest(*request).Execute()
transactionID := response.GetTransactionId()
status := response.GetStatus()
```

--------------------------------

### Get a Beacon Duplicate Python Example

Source: https://plaid.com/docs/api/products/beacon

Retrieves a Beacon Duplicate record using the Python client library.

```python
client = create_client()
request = BeaconDuplicateGetRequest(beacon_duplicate_id='becdup_11111111111111')
response = client.beacon_duplicate_get(request)
```

--------------------------------

### Create Entity Watchlist Screening in Go

Source: https://plaid.com/docs/api/products/monitor

Example of creating an entity watchlist screening using the Plaid Go client.

```go
searchTerms := plaid.NewEntityWatchlistSearchTerms(
  "entprg_2eRPsDnL66rZ7H",
  "Example Screening Entity",
)
searchTerms.SetEmailAddress("user@example.com")
searchTerms.SetPhoneNumber("+14025671234")
searchTerms.SetDocumentNumber("C31195855")
searchTerms.SetUrl("https://example.com")
searchTerms.SetCountry("US")

request := plaid.NewWatchlistScreeningEntityCreateRequest(*searchTerms)
request.SetClientUserId("example-client-user-id-123")

response, _, err := client.PlaidApi.
  WatchlistScreeningEntityCreate(ctx).
  WatchlistScreeningEntityCreateRequest(*request).
  Execute()
```

--------------------------------

### Get a Beacon Duplicate Java Example

Source: https://plaid.com/docs/api/products/beacon

Retrieves a Beacon Duplicate record using the Java client library.

```java
Client client = createClient();
BeaconDuplicateGetRequest request = new BeaconDuplicateGetRequest().beaconDuplicateId("becdup_11111111111111");
Response response = client.beaconDuplicateGet(request).execute();
```
Tokens:
Raw