Nickel Palladium Manganese

    plaid
    TypeScript icon, indicating that this package has built-in type declarations

    12.1.0 • Public • Published

    plaid-node Circle CI npm version

    The official node.js client library for the Plaid API.

    Table of Contents

    Install

    $ npm install plaid

    Versioning

    This release only supports the latest Plaid API version, 2020-09-14, and is generated from our OpenAPI schema.

    import { Configuration, PlaidApi, PlaidEnvironments } from 'plaid';
    
    const configuration = new Configuration({
      basePath: PlaidEnvironments.sandbox,
      baseOptions: {
        headers: {
          'PLAID-CLIENT-ID': CLIENT_ID,
          'PLAID-SECRET': SECRET,
        },
      },
    });
    
    const client = new PlaidApi(configuration);

    For information about what has changed between versions and how to update your integration, head to the API upgrade guide.

    The plaid-node client library is typically updated on a monthly basis. The canonical source for the latest version number is the client library changelog.

    Data type differences from API and from previous versions

    Dates

    Dates and datetimes in requests and responses are represented in this version of the Node client library as strings.

    Time zone information is required for request fields that accept datetimes. Failing to include time zone information will result in an error. See the following examples for guidance on syntax.

    If the API reference documentation for a field specifies format: date, use a string formatted as 'YYYY-MM-DD':

    const start_date = '2022-05-05';

    If the API reference documentation for a field specifies format: date-time, use a string formatted as 'YYYY-MM-DDTHH:mm:ssZ':

    const start_date = '2019-12-12T22:35:49Z';

    Enums

    While the API and previous library versions represent enums using strings, this current library allows either strings or Node enums.

    Old:

    products: ['auth', 'transactions'],

    Current:

    products: ['auth', 'transactions'],
    
    // or
    
    const { Products } = require("plaid");
    
    products: [Products.Auth, Products.Transactions],

    Getting started

    The module supports all Plaid API endpoints. For complete information about the API, head to the docs.

    Most endpoints require a valid client_id and secret as authentication. Attach them via the configuration.

    import { Configuration, PlaidApi, PlaidEnvironments } from 'plaid';
    
    const configuration = new Configuration({
      basePath: PlaidEnvironments.sandbox,
      baseOptions: {
        headers: {
          'PLAID-CLIENT-ID': CLIENT_ID,
          'PLAID-SECRET': SECRET,
        },
      },
    });

    The PlaidEnvironments parameter dictates which Plaid API environment you will access. Values are:

    The baseOptions field allows for clients to override the default options used to make requests. e.g.

    const configuration = new Configuration({
      basePath: PlaidEnvironments.sandbox,
      baseOptions: {
        // Axios request options
      },
    });

    Error Handling

    All errors can now be caught using try/catch with async/await or through promise chaining.

    try {
      await plaidClient.transactionsSync(request);
    } catch (error) {
      const err = error.response.data;
    }
    
    // or
    
    plaidClient
      .transactionsSync(request)
      .then((data) => {
        console.log(data);
      })
      .catch((e) => {
        console.log(e.response.data);
      });

    Examples

    Exchange a public_token from Plaid Link for a Plaid access_token and then retrieve account data:

    const response = await plaidClient.itemPublicTokenExchange({ public_token });
    const access_token = response.data.access_token;
    const accounts_response = await plaidClient.accountsGet({ access_token });
    const accounts = accounts_response.data.accounts;

    Retrieve the last 100 transactions for a transactions user (new, recommended method):

    const response = await plaidClient.transactionsSync({
      access_token
    });
    const transactions = response.data.transactions;
    );

    Retrieve the transactions for a transactions user for the last thirty days (using the older method):

    const now = moment();
    const today = now.format('YYYY-MM-DD');
    const thirtyDaysAgo = now.subtract(30, 'days').format('YYYY-MM-DD');
    
    const response = await plaidClient.transactionsGet({
      access_token,
      start_date: thirtyDaysAgo,
      end_date: today,
    });
    const transactions = response.data.transactions;
    console.log(
      `You have ${transactions.length} transactions from the last thirty days.`,
    );

    Get accounts for a particular Item:

    const response = await plaidClient.accountsGet({
      access_token,
      options: {
        account_ids: ['123456790'],
      },
    });
    console.log(response.data.accounts);

    Payment Initiation

    For more information about this product, head to the Payment Initiation docs.

    Create payment recipient using IBAN and address without BACS

    const name = 'John Doe';
    const iban = 'NL02ABNA0123456789';
    const address = {
      street: ['street name 999'],
      city: 'London',
      postal_code: '99999',
      country: 'GB',
    };
    
    // Passing bacs as null
    const response = await plaidClient.paymentInitiationRecipientCreate({
      name,
      iban,
      address,
    });
    console.log(response.data.recipient_id);

    Create payment recipient using BACS with no IBAN or address

    const name = 'John Doe';
    const bacs = {
      account: '26207729',
      sort_code: '560029',
    };
    
    // For UK recipients, only bacs is required. iban and address are null
    const response = await plaidClient.paymentInitiationRecipientCreate({
      name,
      bacs,
    });
    console.log(response.data.recipient_id);

    Create payment

    const reference = 'testPayment';
    const amount = {
      currency: 'GBP',
      value: 100.0,
    };
    
    const response = await plaidClient.paymentInitiationPaymentCreate({
      recipient_id,
      reference,
      amount,
    });
    console.log(response.data.payment_id);
    console.log(response.data.status);

    Create Link Token (for Payment Initiation only)

    const response = await plaidClient.linkTokenCreate({
      user: {
        client_user_id: '123-test-user-id',
      },
      client_name: 'Plaid Test App',
      products: ['payment_initiation'],
      country_codes: ['GB'],
      language: 'en',
      payment_initiation: {
        payment_id: 'some_payment_id',
      },
    });
    
    console.log(response.data.link_token);

    Download Asset Report PDF

    const pdfResp = await plaidClient.assetReportPdfGet(
      {
        asset_report_token: assetReportToken,
      },
      {
        responseType: 'arraybuffer',
      },
    );
    
    fs.writeFileSync('asset_report.pdf', pdfResp.data);

    Promise Support

    Every method returns a promise, so you can use async/await or promise chaining.

    API methods that return either a success or an error can be used with the usual then/catch paradigm, e.g.

    plaidPromise
      .then((successResponse) => {
        // ...
      })
      .catch((err) => {
        // ...
      });

    For example:

    import * as bodyParser from 'body-parser';
    import * as express from 'express';
    import { Configuration, PlaidApi, PlaidEnvironments } from 'plaid';
    
    const configuration = new Configuration({
      basePath: PlaidEnvironments.sandbox,
      baseOptions: {
        headers: {
          'PLAID-CLIENT-ID': CLIENT_ID,
          'PLAID-SECRET': SECRET,
          'Plaid-Version': '2020-09-14',
        },
      },
    });
    
    const plaidClient = new PlaidApi(configuration);
    
    const app = express();
    const port = process.env.PORT || 3000;
    
    app.use(
      bodyParser.urlencoded({
        extended: true,
      }),
    );
    app.use(bodyParser.json());
    
    app.post('/plaid_exchange', (req, res) => {
      var public_token = req.body.public_token;
    
      return plaidClient
        .itemPublicTokenExchange({ public_token })
        .then((tokenResponse) => tokenResponse.access_token)
        .then((accessToken) => plaidClient.accountsGet({ accessToken }))
        .then((accountsResponse) => console.log(accountsResponse.accounts))
        .catch((error) => {
          const err = error.response.data;
    
          // Indicates plaid API error
          console.error('/exchange token returned an error', {
            error_type: err.error_type,
            error_code: err.error_code,
            error_message: err.error_message,
            display_message: err.display_message,
            documentation_url: err.documentation_url,
            request_id: err.request_id,
          });
    
          // Inspect error_type to handle the error in your application
          switch (err.error_type) {
            case 'INVALID_REQUEST':
              // ...
              break;
            case 'INVALID_INPUT':
              // ...
              break;
            case 'RATE_LIMIT_EXCEEDED':
              // ...
              break;
            case 'API_ERROR':
              // ...
              break;
            case 'ITEM_ERROR':
              // ...
              break;
            default:
            // fallthrough
          }
    
          res.sendStatus(500);
        });
    });
    
    app.listen(port, () => {
      console.log(`Listening on port ${port}`);
    });

    Support

    Open an issue!

    Contributing

    Click here!

    License

    MIT

    Install

    npm i plaid

    DownloadsWeekly Downloads

    77,311

    Version

    12.1.0

    License

    MIT

    Unpacked Size

    8.68 MB

    Total Files

    31

    Last publish

    Collaborators

    • amcbride
    • timruffles
    • njt
    • plaid-admin
    • andchen
    • aeidelson-plaid
    • arbitton
    • sbrown
    • cfarmerplaid
    • stephenjayakar
    • mnguyen-plaid
    • pchen-plaid