git clone https://github.com/plaid/quickstart.git
cd quickstart/ruby

# Install dependencies
bundle

# Start the Quickstart with your API keys from the Dashboard
# https://dashboard.plaid.com/account/keys
#
# PLAID_PRODUCTS is a comma-separated list of products to use when
# initializing Link, see https://plaid.com/docs/#item-product-access
# for complete list.
#
# PLAID_COUNTRY_CODES is a comma-separated list of countries to use when
# initializing Link, see plaid.com/docs/faq/#does-plaid-support-international-bank-accounts-
# for a complete list

PLAID_CLIENT_ID='CLIENT_ID' \
PLAID_SECRET='SECRET' \
PLAID_ENV='sandbox' \
PLAID_PRODUCTS='transactions' \
PLAID_COUNTRY_CODES='US' \
ruby app.rb
# Go to http://localhost:4567
          

git clone https://github.com/plaid/quickstart.git
cd quickstart/python

# For virtualenv users
# virtualenv venv
# source venv/bin/activate

pip install -r requirements.txt

# Start the Quickstart with your API keys from the Dashboard
# https://dashboard.plaid.com/account/keys
#
# PLAID_PRODUCTS is a comma-separated list of products to use when
# initializing Link, see https://plaid.com/docs/#item-product-access
# for complete list.
#
# PLAID_COUNTRY_CODES is a comma-separated list of countries to use when
# initializing Link, see plaid.com/docs/faq/#does-plaid-support-international-bank-accounts-
# for a complete list

PLAID_CLIENT_ID='CLIENT_ID' \
PLAID_SECRET='SECRET' \
PLAID_ENV='sandbox' \
PLAID_PRODUCTS='transactions' \
PLAID_COUNTRY_CODES='US' \
python server.py
# Go to http://localhost:5000
          

git clone https://github.com/plaid/quickstart.git
cd quickstart/ruby

# Install dependencies
bundle

# You will need to configure the PLAID_REDIRECT_URI for
# your client ID through the Plaid developer dashboard at
# https://dashboard.plaid.com/team/api.
#
# Start the Quickstart with your API keys from the Dashboard
# https://dashboard.plaid.com/account/keys
#
# PLAID_PRODUCTS is a comma-separated list of products to use when
# initializing Link, see https://plaid.com/docs/#item-product-access
# for complete list.

PLAID_CLIENT_ID='CLIENT_ID' \
PLAID_SECRET='SECRET' \
PLAID_ENV='sandbox' \
PLAID_PRODUCTS='transactions' \
PLAID_COUNTRY_CODES='GB,FR,ES,IE,NL' \
PLAID_REDIRECT_URI='http://localhost:4567/oauth-response.html' \
ruby app.rb

# Go to http://localhost:4567
          

git clone https://github.com/plaid/quickstart.git
cd quickstart/python

# For virtualenv users
# virtualenv venv
# source venv/bin/activate

pip install -r requirements.txt

# You will need to configure the PLAID_REDIRECT_URI for
# your client ID through the Plaid developer dashboard at
# https://dashboard.plaid.com/team/api.
#
# Start the Quickstart with your API keys from the Dashboard
# https://dashboard.plaid.com/account/keys
#
# PLAID_PRODUCTS is a comma-separated list of products to use when
# initializing Link, see https://plaid.com/docs/#item-product-access
# for complete list.

PLAID_CLIENT_ID='CLIENT_ID' \
PLAID_SECRET='SECRET' \
PLAID_ENV='sandbox' \
PLAID_PRODUCTS='transactions' \
PLAID_COUNTRY_CODES='GB,FR,ES,IE,NL' \
PLAID_REDIRECT_URI='http://localhost:5000/oauth-response.html' \
python server.py

# Go to http://localhost:5000
          

    import plaid from 'plaid'
    import express from 'express';

    const app = express();

    const plaidClient = new plaid.Client({
      clientID: PLAID_CLIENT_ID,
      secret: PLAID_SECRET,
      env: PLAID_ENVIRONMENT,
      options: { version: '2019-05-29' },
    })

    app.post('/create_link_token', async function(request, response, next) {
      // 1. Grab the client_user_id by searching for the current user in your database
      const user = await User.find(...);
      const clientUserId = user.id;

      // 2. Create a link_token for the given user
      plaidClient.createLinkToken({ 
        user: { 
          client_user_id: clientUserId,
        },
        client_name: 'My App',
        products: ['transactions'],
        country_codes: ['US'],
        language: 'en',
        webhook: 'https://sample.webhook.com',
      }, (err, res) => {
        const link_token = res.link_token;

        // 3. Send the data to the client
        response.json({ link_token });
      });
    });

    app.listen(3000, function() {
      console.log('server listening on port 3000');
    });
  

    require 'plaid'
    require 'json'
    require 'sinatra'

    client = Plaid::Client.new(env: PLAID_ENVIRONMENT,
                               client_id: PLAID_CLIENT_ID,
                               secret: PLAID_SECRET)

    post '/create_link_token' do
      # 1. Grab the client_user_id by searching for the current user in your database
      current_user = User.find(...)
      client_user_id = current_user.id

      # 2. Create a link_token for the given user
      response = client.link_token.create(
        user: {
          client_user_id: client_user_id
        },
        client_name: 'My App',
        products: ['transactions'],
        country_codes: ['US'],
        language: 'en',
        webhook: 'https://sample.webhook.com',
      )
      link_token = response['link_token']

      # 3. Send the data to the client
      content_type :json
      response.to_json
    end
  

    import plaid
    import json
    from flask import Flask
    from flask import request
    from flask import jsonify

    app = Flask(<strong>name</strong>)

    client = plaid.Client(client_id=PLAID_CLIENT_ID,
                          secret=PLAID_SECRET,
                          environment=PLAID_ENV,
                          api_version='2019-05-29')

    @app.route('/create_link_token')
      # 1. Grab the client_user_id by searching for the current user in your database
      user = User.find(...)
      client_user_id = user.id

      # 2. Create a link_token for the given user
      response = client.LinkToken.create({
        'user': {
          'client_user_id': client_user_id,
        },
        'products': ["transactions"],
        'client_name': "My App",
        'country_codes': ['US'],
        'language': 'en',
        'webhook': 'https://sample.webhook.com',
      })
      link_token = response['link_token']

      # 3. Send the data to the client
      return jsonify(response)

    if __name__ == '__main__':
      app.run(port=3000)
  

    <button id="link-button">Link Account</button>
    <script src="https://cdn.plaid.com/link/v2/stable/link-initialize.js"></script>
    <script type="text/javascript">
    (async function() {
      const fetchLinkToken = async () => {
        const response = await fetch('/create_link_token', { method: 'POST' });
        const responseJSON = await response.json();
        return responseJSON.link_token;
      };

      const configs = {
        // 1. Pass a new link_token to Link.
        token: await fetchLinkToken(),
        onSuccess: async function(public_token, metadata) {
          // 2a. Send the public_token to your app server.
          // The onSuccess function is called when the user has successfully
          // authenticated and selected an account to use.
          await fetch('/get_access_token', { 
            method: 'POST',
            body: JSON.stringify({ public_token: public_token }),
          });
        },
        onExit: async function(err, metadata) {
          // 2b. Gracefully handle the invalid link token error. A link token
          // can become invalidated if it expires, has already been used
          // for a link session, or is associated with too many invalid logins.
          if (err != null && err.error_code === 'INVALID_LINK_TOKEN') {
            linkHandler.destroy();
            linkHandler = Plaid.create({
              ...configs,
              token: await fetchLinkToken(),
            });
          }
          if (err != null) {
            // Handle any other types of errors.
          }
          // metadata contains information about the institution that the
          // user selected and the most recent API request IDs.
          // Storing this information can be helpful for support.
        },
      };

      var linkHandler = Plaid.create(configs);

      document.getElementById('link-button').onclick = function() {
        linkHandler.open();
      };
    })();
    </script>
  

    <button id="link-button">Link Account</button>
    <script src="https://cdn.plaid.com/link/v2/stable/link-initialize.js"></script>
    <script type="text/javascript">
    (async function() {
      const fetchLinkToken = async () => {
        const response = await fetch('/create_link_token', { method: 'POST' });
        const responseJSON = await response.json();
        return responseJSON.link_token;
      };

      const configs = {
        // 1. Pass a new link_token to Link.
        token: await fetchLinkToken(),
        onSuccess: async function(public_token, metadata) {
          // 2a. Send the public_token to your app server.
          // The onSuccess function is called when the user has successfully
          // authenticated and selected an account to use.
          await fetch('/get_access_token', { 
            method: 'POST',
            body: JSON.stringify({ public_token: public_token }),
          });
        },
        onExit: async function(err, metadata) {
          // 2b. Gracefully handle the invalid link token error. A link token
          // can become invalidated if it expires, has already been used
          // for a link session, or is associated with too many invalid logins.
          if (err != null && err.error_code === 'INVALID_LINK_TOKEN') {
            linkHandler.destroy();
            linkHandler = Plaid.create({
              ...configs,
              token: await fetchLinkToken(),
            });
          }
          if (err != null) {
            // Handle any other types of errors.
          }
          // metadata contains information about the institution that the
          // user selected and the most recent API request IDs.
          // Storing this information can be helpful for support.
        },
      };

      var linkHandler = Plaid.create(configs);

      document.getElementById('link-button').onclick = function() {
        linkHandler.open();
      };
    })();
    </script>
  

require 'date'
require 'json'
require 'plaid'
require 'sinatra'

set :public_folder, File.dirname(__FILE__) + '/static'

client = Plaid::Client.new(env: ENV['PLAID_ENV'],
                           client_id: ENV['PLAID_CLIENT_ID'],
                           secret: ENV['PLAID_SECRET'])

access_token = nil

get '/' do
  erb :index
end

post '/get_access_token' do
  exchange_token_response =
    client.item.public_token.exchange(params['public_token'])
  access_token = exchange_token_response['access_token']
  pretty_print_response(exchange_token_response)

  content_type :json
  exchange_token_response.to_json
end
          

import os
import datetime
import plaid
import json
from flask import Flask
from flask import render_template
from flask import request
from flask import jsonify

app = Flask(__name__)

PLAID_CLIENT_ID = os.getenv('PLAID_CLIENT_ID')
PLAID_SECRET = os.getenv('PLAID_SECRET')
# Use 'sandbox' to test with Plaid's Sandbox environment (username: user_good,
# password: pass_good)
# Use development to test with live users and credentials and production
# to go live
PLAID_ENV = os.getenv('PLAID_ENV', 'sandbox')


client = plaid.Client(
    client_id=PLAID_CLIENT_ID,
    secret=PLAID_SECRET,
    environment=PLAID_ENV,
    api_version='2018-05-22'
)

@app.route('/')
def index():
    return render_template('index.ejs')

access_token = None

@app.route('/get_access_token', methods=['POST'])
def get_access_token():
    global access_token
    public_token = request.form['public_token']
    exchange_response = \
        client.Item.public_token.exchange(public_token)
    access_token = exchange_response['access_token']

    pretty_print_response(exchange_response)

    return jsonify(exchange_response)

          

# Retrieve ACH or EFT account numbers for an Item
# https://plaid.com/docs/#auth
get '/auth' do
  begin
    product_response = client.auth.get(access_token)
    pretty_print_response(product_response)
    content_type :json
    { auth: product_response }.to_json
  rescue Plaid::PlaidAPIError => e
    error_response = format_error(e)
    pretty_print_response(error_response)
    content_type :json
    error_response.to_json
  end
end
          

# Retrieve ACH or EFT account numbers for an Item
# https://plaid.com/docs/#auth
@app.route('/auth', methods=['GET'])
def get_auth():
    try:
        auth_response = client.Auth.get(access_token)
    except plaid.errors.PlaidError as e:
        return jsonify({'error': {'display_message': e.display_message, 'error_code': e.code, 'error_type': e.type } })
    pretty_print_response(auth_response)
    return jsonify({'error': None, 'auth': auth_response})
          

# Retrieve Transactions for an Item
# https://plaid.com/docs/#transactions
get '/transactions' do
  now = Date.today
  thirty_days_ago = (now - 30)
  begin
    product_response =
      client.transactions.get(access_token, thirty_days_ago, now)
    pretty_print_response(product_response)
    content_type :json
    { transactions => product_response }.to_json
  rescue Plaid::PlaidAPIError => e
    error_response = format_error(e)
    pretty_print_response(error_response)
    content_type :json
    error_response.to_json
  end
end
          

# Retrieve Transactions for an Item
# https://plaid.com/docs/#transactions
@app.route('/transactions', methods=['GET'])
def get_transactions():
    # Pull transactions for the last 30 days
    start_date = '{:%Y-%m-%d}'.format(datetime.datetime.now() + datetime.timedelta(-30))
    end_date = '{:%Y-%m-%d}'.format(datetime.datetime.now())
    try:
        transactions_response = client.Transactions.get(access_token, start_date, end_date)
    except plaid.errors.PlaidError as e:
        return jsonify({'error': {'display_message': e.display_message, 'error_code': e.code, 'error_type': e.type } })
    pretty_print_response(transactions_response)
    return jsonify({'error': None, 'transactions': transactions_response})
          

# Create a one-time use access_token for the Item.
# This access_token can be used to initialize Link
# in update mode for the user.
post '/create_link_token' do
    # 1. Grab the client_user_id by searching for the current user in your database
    current_user = User.find(...)
    client_user_id = current_user.id

    # 2. Create a link_token for the given user
    response = client.link_token.create(
      user: {
        client_user_id: client_user_id
      },
      client_name: 'My App',
      country_codes: ['US'],
      language: 'en',
      access_token: ACCESS_TOKEN,
    )
    link_token = response['link_token']

    # 3. Send the data to the client
    content_type :json
    response.to_json
end
          

# Create a one-time use link_token for the Item.
# This public_token can be used to initialize Link
# in update mode for the user.
@app.route("/create_link_token", methods=['POST'])
def create_public_token():
    # 1. Grab the client_user_id by searching for the current user in your database
    user = User.find(...)
    client_user_id = user.id

    # 2. Create a link_token for the given user
    response = client.LinkToken.create({
      'user': {
        'client_user_id': client_user_id,
      },
      'client_name': "My App",
      'country_codes': ['US'],
      'language': 'en',
      'access_token': ACCESS_TOKEN,
    })
    link_token = response['link_token']

    # 3. Send the data to the client
    return jsonify(response)
          

var handler = Plaid.create({
  token: 'GENERATED_LINK_TOKEN',
  onSuccess: function(public_token, metadata) {},
  onExit: function(err, metadata) {},
  onEvent: function(eventName, metadata) {}
});
          

var handler = Plaid.create({
  token: 'CREATED_LINK_TOKEN',
  onSuccess: function(public_token, metadata) {},
  onExit: function(err, metadata) {},
  onEvent: function(eventName, metadata) {}
});
          

# Force a Sandbox Item into an error state
client.sandbox.sandbox_item.reset_login(access_token)
# create a link_token for the Item and use it to initialize Link
# in update mode.
link_token_response = client.link_token.create(
  user: {
    client_user_id: User.find(...).id
  },
  client_name: 'My App',
  country_codes: ['US'],
  language: 'en',
  access_token: access_token
)
          

# Force a Sandbox Item into an error state
client.Sandbox.item.reset_login(access_token)
# create a link_token for the Item and use it to initialize Link
# in update mode.
link_token_response = client.LinkToken.create({
  'user': {
    'client_user_id': User.find(...).id
  },
  'client_name': 'My App',
  'country_codes': ['US'],
  'language': 'en',
  'access_token': access_token
})