+ The Plaid flow begins when your user wants to connect their bank
+ account to your app. Simulate this by clicking the button below to
+ launch Link - the client-side component that your users will
+ interact with in order to link their accounts to Plaid and allow you
+ to access their accounts via the Plaid API.
+
+ {/* message if backend is not running and there is no link token */}
+ {!backend ? (
+
+ Unable to fetch link_token: please make sure your backend server
+ is running and that your .env file has been configured with your
+ PLAID_CLIENT_ID and PLAID_SECRET.
+
+ ) : /* message if backend is running and there is no link token */
+ linkToken == null && backend ? (
+
+
+ Unable to fetch link_token: please make sure your backend server
+ is running and that your .env file has been configured
+ correctly.
+
+
+ If you are on a Windows machine, please ensure that you have
+ cloned the repo with{" "}
+
+ symlinks turned on.
+ {" "}
+ You can also try checking your{" "}
+
+ activity log
+ {" "}
+ on your Plaid dashboard.
+
+
+ You can see information of all your payments in the{" "}
+
+ Payments Dashboard
+
+ .
+
+
+
+ Now that the 'payment_id' stored in your server, you can use it
+ to access the payment information:
+
+
+ ) : (
+ /* If not using the payment_initiation product, show the item_id and access_token information */ <>
+ {isItemAccess ? (
+
+ Congrats! By linking an account, you have created an{" "}
+
+ Item
+
+ .
+
+ ) : userToken || userId ? (
+
+ Congrats! You have successfully linked data to a User.
+
+ ) : (
+
+
+ Unable to create an item. Please check your backend server
+
+
+ )}
+
+ {itemId && (
+
+ item_id
+ {itemId}
+
+ )}
+
+ {accessToken && (
+
+ access_token
+ {accessToken}
+
+ )}
+
+ {userToken && (
+
+ user_token
+ {userToken}
+
+ )}
+
+ {userId && (
+
+ user_id
+ {userId}
+
+ )}
+
+ {(isItemAccess || userToken || userId) && (
+
+ Now that you have {accessToken && "an access_token"}
+ {accessToken && (userToken || userId) && " and "}
+ {userToken && "a user_token"}
+ {userToken && userId && " and "}
+ {userId && "a user_id"}, you can make all of the
+ following requests:
+
- This is an example application that walks through integrating Plaid Link using the API to retrieve Auth and Transaction data.
-
-
- Great - you just created an Item! The server was successfully able to exchange the public_token for an access_token.
- Below are a few options - you can get account data, retrieve information about the Item itself, or pull transaction data.
-
-
-
-
-
- Click the button below to open a list of Institutions - after you select one,
- you'll be guided through an authentication process. The public_token will be passed
- back to the example server, which will then exchange it for an access token and log it
- to your console.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/python/.env b/python/.env
new file mode 120000
index 000000000..4a82335f5
--- /dev/null
+++ b/python/.env
@@ -0,0 +1 @@
+../.env
\ No newline at end of file
diff --git a/python/.env.example b/python/.env.example
new file mode 120000
index 000000000..821f01742
--- /dev/null
+++ b/python/.env.example
@@ -0,0 +1 @@
+../.env.example
\ No newline at end of file
diff --git a/python/Dockerfile b/python/Dockerfile
new file mode 100644
index 000000000..be1b5d032
--- /dev/null
+++ b/python/Dockerfile
@@ -0,0 +1,12 @@
+FROM python:3.12.12-alpine
+
+WORKDIR /opt/app
+COPY . .
+WORKDIR /opt/app/python
+
+RUN pip3 install -r requirements.txt
+
+ENV FLASK_APP=/opt/app/python/server.py
+EXPOSE 8000
+ENTRYPOINT ["python"]
+CMD ["-m", "flask", "run", "--host=0.0.0.0", "--port=8000"]
diff --git a/python/README.md b/python/README.md
deleted file mode 100644
index af7205fec..000000000
--- a/python/README.md
+++ /dev/null
@@ -1,17 +0,0 @@
-### plaid-python quickstart
-
-[Quickstart guide](https://plaid.com/docs/quickstart)
-
-``` bash
-git clone https://github.com/plaid/quickstart.git
-cd quickstart/python
-pip install -r requirements.txt
-
-# Fill in your Plaid API keys (client ID, secret, public_key)
-# to test!
-PLAID_CLIENT_ID=[CLIENT_ID] \
-PLAID_SECRET=[SECRET] \
-PLAID_PUBLIC_KEY=[PUBLIC_KEY] \
-python server.py
-# Go to http://localhost:5000
-```
diff --git a/python/requirements.txt b/python/requirements.txt
index 7506a9551..4b2407343 100644
--- a/python/requirements.txt
+++ b/python/requirements.txt
@@ -1,9 +1,5 @@
-Flask==0.12
-Jinja2==2.9.5
-MarkupSafe==0.23
-Werkzeug==0.11.15
-click==6.7
-itsdangerous==0.24
-requests==2.13.0
-wsgiref==0.1.2;python_version<'3.0'
-plaid-python>=2.0,<2.1
+Flask==3.1.2
+plaid_python==38.1.0
+python-dotenv==1.2.1
+itsdangerous==2.2.0
+werkzeug==3.1.5
diff --git a/python/server.py b/python/server.py
index 066707650..e8a34a4fb 100644
--- a/python/server.py
+++ b/python/server.py
@@ -1,81 +1,849 @@
+# Read env vars from .env file
+import base64
import os
-import datetime
+import datetime as dt
+import json
+import time
+from datetime import date, timedelta
+import uuid
+
+from dotenv import load_dotenv
+from flask import Flask, request, jsonify
import plaid
-from flask import Flask
-from flask import render_template
-from flask import request
-from flask import jsonify
+from plaid.model.payment_amount import PaymentAmount
+from plaid.model.payment_amount_currency import PaymentAmountCurrency
+from plaid.model.products import Products
+from plaid.model.country_code import CountryCode
+from plaid.model.recipient_bacs_nullable import RecipientBACSNullable
+from plaid.model.payment_initiation_address import PaymentInitiationAddress
+from plaid.model.payment_initiation_recipient_create_request import PaymentInitiationRecipientCreateRequest
+from plaid.model.payment_initiation_payment_create_request import PaymentInitiationPaymentCreateRequest
+from plaid.model.payment_initiation_payment_get_request import PaymentInitiationPaymentGetRequest
+from plaid.model.link_token_create_request_payment_initiation import LinkTokenCreateRequestPaymentInitiation
+from plaid.model.item_public_token_exchange_request import ItemPublicTokenExchangeRequest
+from plaid.model.link_token_create_request import LinkTokenCreateRequest
+from plaid.model.link_token_create_request_user import LinkTokenCreateRequestUser
+from plaid.model.user_create_request import UserCreateRequest
+from plaid.model.consumer_report_user_identity import ConsumerReportUserIdentity
+from plaid.model.client_user_identity import ClientUserIdentity
+from plaid.model.asset_report_create_request import AssetReportCreateRequest
+from plaid.model.asset_report_create_request_options import AssetReportCreateRequestOptions
+from plaid.model.asset_report_user import AssetReportUser
+from plaid.model.asset_report_get_request import AssetReportGetRequest
+from plaid.model.asset_report_pdf_get_request import AssetReportPDFGetRequest
+from plaid.model.auth_get_request import AuthGetRequest
+from plaid.model.transactions_sync_request import TransactionsSyncRequest
+from plaid.model.identity_get_request import IdentityGetRequest
+from plaid.model.investments_transactions_get_request_options import InvestmentsTransactionsGetRequestOptions
+from plaid.model.investments_transactions_get_request import InvestmentsTransactionsGetRequest
+from plaid.model.accounts_balance_get_request import AccountsBalanceGetRequest
+from plaid.model.accounts_get_request import AccountsGetRequest
+from plaid.model.investments_holdings_get_request import InvestmentsHoldingsGetRequest
+from plaid.model.item_get_request import ItemGetRequest
+from plaid.model.institutions_get_by_id_request import InstitutionsGetByIdRequest
+from plaid.model.transfer_authorization_create_request import TransferAuthorizationCreateRequest
+from plaid.model.transfer_create_request import TransferCreateRequest
+from plaid.model.transfer_get_request import TransferGetRequest
+from plaid.model.transfer_network import TransferNetwork
+from plaid.model.transfer_type import TransferType
+from plaid.model.transfer_authorization_user_in_request import TransferAuthorizationUserInRequest
+from plaid.model.ach_class import ACHClass
+from plaid.model.transfer_create_idempotency_key import TransferCreateIdempotencyKey
+from plaid.model.transfer_user_address_in_request import TransferUserAddressInRequest
+from plaid.model.signal_evaluate_request import SignalEvaluateRequest
+from plaid.model.statements_list_request import StatementsListRequest
+from plaid.model.link_token_create_request_statements import LinkTokenCreateRequestStatements
+from plaid.model.link_token_create_request_cra_options import LinkTokenCreateRequestCraOptions
+from plaid.model.statements_download_request import StatementsDownloadRequest
+from plaid.model.consumer_report_permissible_purpose import ConsumerReportPermissiblePurpose
+from plaid.model.cra_check_report_base_report_get_request import CraCheckReportBaseReportGetRequest
+from plaid.model.cra_check_report_pdf_get_request import CraCheckReportPDFGetRequest
+from plaid.model.cra_check_report_income_insights_get_request import CraCheckReportIncomeInsightsGetRequest
+from plaid.model.cra_check_report_partner_insights_get_request import CraCheckReportPartnerInsightsGetRequest
+from plaid.model.cra_pdf_add_ons import CraPDFAddOns
+from plaid.api import plaid_api
-app = Flask(__name__)
+load_dotenv()
-# Fill in your Plaid API keys - https://dashboard.plaid.com/account/keys
+app = Flask(__name__)
+
PLAID_CLIENT_ID = os.getenv('PLAID_CLIENT_ID')
PLAID_SECRET = os.getenv('PLAID_SECRET')
-PLAID_PUBLIC_KEY = os.getenv('PLAID_PUBLIC_KEY')
-# 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')
+PLAID_PRODUCTS = os.getenv('PLAID_PRODUCTS', 'transactions').split(',')
+PLAID_COUNTRY_CODES = os.getenv('PLAID_COUNTRY_CODES', 'US').split(',')
+SIGNAL_RULESET_KEY = os.getenv('SIGNAL_RULESET_KEY', '')
+
+def empty_to_none(field):
+ value = os.getenv(field)
+ if value is None or len(value) == 0:
+ return None
+ return value
+
+host = plaid.Environment.Sandbox
+
+if PLAID_ENV == 'sandbox':
+ host = plaid.Environment.Sandbox
-client = plaid.Client(client_id = PLAID_CLIENT_ID, secret=PLAID_SECRET,
- public_key=PLAID_PUBLIC_KEY, environment=PLAID_ENV)
+if PLAID_ENV == 'production':
+ host = plaid.Environment.Production
-@app.route("/")
-def index():
- return render_template('index.ejs', plaid_public_key=PLAID_PUBLIC_KEY, plaid_environment=PLAID_ENV)
+# Parameters used for the OAuth redirect Link flow.
+#
+# Set PLAID_REDIRECT_URI to 'http://localhost:3000/'
+# The OAuth redirect flow requires an endpoint on the developer's website
+# that the bank website should redirect to. You will need to configure
+# this redirect URI for your client ID through the Plaid developer dashboard
+# at https://dashboard.plaid.com/team/api.
+PLAID_REDIRECT_URI = empty_to_none('PLAID_REDIRECT_URI')
+configuration = plaid.Configuration(
+ host=host,
+ api_key={
+ 'clientId': PLAID_CLIENT_ID,
+ 'secret': PLAID_SECRET,
+ 'plaidVersion': '2020-09-14'
+ }
+)
+api_client = plaid.ApiClient(configuration)
+client = plaid_api.PlaidApi(api_client)
+
+products = []
+for product in PLAID_PRODUCTS:
+ products.append(Products(product))
+
+
+# We store the access_token in memory - in production, store it in a secure
+# persistent data store.
access_token = None
-public_token = None
+# The payment_id is only relevant for the UK Payment Initiation product.
+# We store the payment_id in memory - in production, store it in a secure
+# persistent data store.
+payment_id = None
+# The transfer_id is only relevant for Transfer ACH product.
+# We store the transfer_id in memory - in production, store it in a secure
+# persistent data store.
+transfer_id = None
+# We store the user_token in memory - in production, store it in a secure
+# persistent data store.
+user_token = None
+user_id = None
+
+item_id = None
+
+
+@app.route('/api/info', methods=['POST'])
+def info():
+ global access_token
+ global item_id
+ return jsonify({
+ 'item_id': item_id,
+ 'access_token': access_token,
+ 'products': PLAID_PRODUCTS
+ })
+
+
+@app.route('/api/create_link_token_for_payment', methods=['POST'])
+def create_link_token_for_payment():
+ global payment_id
+ try:
+ request = PaymentInitiationRecipientCreateRequest(
+ name='John Doe',
+ bacs=RecipientBACSNullable(account='26207729', sort_code='560029'),
+ address=PaymentInitiationAddress(
+ street=['street name 999'],
+ city='city',
+ postal_code='99999',
+ country='GB'
+ )
+ )
+ response = client.payment_initiation_recipient_create(
+ request)
+ recipient_id = response['recipient_id']
+
+ request = PaymentInitiationPaymentCreateRequest(
+ recipient_id=recipient_id,
+ reference='TestPayment',
+ amount=PaymentAmount(
+ PaymentAmountCurrency('GBP'),
+ value=100.00
+ )
+ )
+ response = client.payment_initiation_payment_create(
+ request
+ )
+ pretty_print_response(response.to_dict())
+
+ # We store the payment_id in memory for demo purposes - in production, store it in a secure
+ # persistent data store along with the Payment metadata, such as userId.
+ payment_id = response['payment_id']
+
+ linkRequest = LinkTokenCreateRequest(
+ # The 'payment_initiation' product has to be the only element in the 'products' list.
+ products=[Products('payment_initiation')],
+ client_name='Plaid Test',
+ # Institutions from all listed countries will be shown.
+ country_codes=list(map(lambda x: CountryCode(x), PLAID_COUNTRY_CODES)),
+ language='en',
+ user=LinkTokenCreateRequestUser(
+ # This should correspond to a unique id for the current user.
+ # Typically, this will be a user ID number from your application.
+ # Personally identifiable information, such as an email address or phone number, should not be used here.
+ client_user_id=str(time.time())
+ ),
+ payment_initiation=LinkTokenCreateRequestPaymentInitiation(
+ payment_id=payment_id
+ )
+ )
+
+ if PLAID_REDIRECT_URI!=None:
+ linkRequest['redirect_uri']=PLAID_REDIRECT_URI
+ linkResponse = client.link_token_create(linkRequest)
+ pretty_print_response(linkResponse.to_dict())
+ return jsonify(linkResponse.to_dict())
+ except plaid.ApiException as e:
+ return json.loads(e.body)
+
+
+@app.route('/api/create_link_token', methods=['POST'])
+def create_link_token():
+ global user_token
+ global user_id
+ try:
+ # Build request based on whether we have user_token or user_id
+ cra_products = ["cra_base_report", "cra_income_insights", "cra_partner_insights"]
+ is_cra = any(product in cra_products for product in PLAID_PRODUCTS)
+
+ if is_cra and user_id and not user_token:
+ # For user_id, don't include user field
+ request = LinkTokenCreateRequest(
+ products=products,
+ client_name="Plaid Quickstart",
+ country_codes=list(map(lambda x: CountryCode(x), PLAID_COUNTRY_CODES)),
+ language='en'
+ )
+ else:
+ # For user_token or non-CRA products, include user field
+ request = LinkTokenCreateRequest(
+ products=products,
+ client_name="Plaid Quickstart",
+ country_codes=list(map(lambda x: CountryCode(x), PLAID_COUNTRY_CODES)),
+ language='en',
+ user=LinkTokenCreateRequestUser(
+ client_user_id=str(time.time())
+ )
+ )
+
+ if PLAID_REDIRECT_URI!=None:
+ request['redirect_uri']=PLAID_REDIRECT_URI
+ if Products('statements') in products:
+ statements=LinkTokenCreateRequestStatements(
+ end_date=date.today(),
+ start_date=date.today()-timedelta(days=30)
+ )
+ request['statements']=statements
+
+ if is_cra:
+ # Use user_token if available, otherwise use user_id
+ if user_token:
+ request['user_token'] = user_token
+ elif user_id:
+ request['user_id'] = user_id
+ request['consumer_report_permissible_purpose'] = ConsumerReportPermissiblePurpose('ACCOUNT_REVIEW_CREDIT')
+ request['cra_options'] = LinkTokenCreateRequestCraOptions(
+ days_requested=60
+ )
+ # create link token
+ response = client.link_token_create(request)
+ return jsonify(response.to_dict())
+ except plaid.ApiException as e:
+ print(e)
+ return json.loads(e.body)
+
+# Create a user token which can be used for Plaid Check, Income, or Multi-Item link flows
+# https://plaid.com/docs/api/users/#usercreate
+@app.route('/api/create_user_token', methods=['POST'])
+def create_user_token():
+ global user_token
+ global user_id
+ client_user_id = "user_" + str(uuid.uuid4())
+
+ try:
+ user_create_request = UserCreateRequest(
+ # Typically this will be a user ID number from your application.
+ client_user_id=client_user_id
+ )
+
+ cra_products = ["cra_base_report", "cra_income_insights", "cra_partner_insights"]
+ if any(product in cra_products for product in PLAID_PRODUCTS):
+ # Try with identity first (new style)
+ identity = ClientUserIdentity(
+ name={
+ "given_name": "Harry",
+ "family_name": "Potter"
+ },
+ date_of_birth= date(1980, 7, 31),
+ phone_numbers= [{
+ "data": '+16174567890',
+ "primary": True
+ }],
+ emails= [{
+ "data": 'harrypotter@example.com',
+ "primary": True
+ }],
+ addresses= [{
+ "street_1": '4 Privet Drive',
+ "city": 'New York',
+ "region": 'NY',
+ "postal_code": '11111',
+ "country": 'US',
+ "primary": True
+ }]
+ )
+ user_create_request["identity"] = identity
+
+ user_response = client.user_create(user_create_request)
+ # Store both user_token and user_id
+ if 'user_token' in user_response:
+ user_token = user_response['user_token']
+ if 'user_id' in user_response:
+ user_id = user_response['user_id']
+ return jsonify(user_response.to_dict())
+ except plaid.ApiException as e:
+ # Retry with consumer_report_user_identity if identity fails
+ error_body = json.loads(e.body)
+ if (error_body.get('error_code') == 'INVALID_FIELD' and
+ any(product in cra_products for product in PLAID_PRODUCTS)):
+ try:
+ retry_request = UserCreateRequest(
+ client_user_id=client_user_id
+ )
+ consumer_report_user_identity = ConsumerReportUserIdentity(
+ first_name="Harry",
+ last_name="Potter",
+ date_of_birth= date(1980, 7, 31),
+ phone_numbers= ['+16174567890'],
+ emails= ['harrypotter@example.com'],
+ primary_address= {
+ "city": 'New York',
+ "region": 'NY',
+ "street": '4 Privet Drive',
+ "postal_code": '11111',
+ "country": 'US'
+ }
+ )
+ retry_request["consumer_report_user_identity"] = consumer_report_user_identity
+ user_response = client.user_create(retry_request)
+ # Store both user_token and user_id
+ if 'user_token' in user_response:
+ user_token = user_response['user_token']
+ if 'user_id' in user_response:
+ user_id = user_response['user_id']
+ return jsonify(user_response.to_dict())
+ except plaid.ApiException as retry_error:
+ print(retry_error)
+ return jsonify(json.loads(retry_error.body)), retry_error.status
+ print(e)
+ return jsonify(json.loads(e.body)), e.status
-@app.route("/get_access_token", methods=['POST'])
+
+# Exchange token flow - exchange a Link public_token for
+# an API access_token
+# https://plaid.com/docs/#exchange-token-flow
+
+
+@app.route('/api/set_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)
- print('public token: ' + public_token)
- print('access token: ' + exchange_response['access_token'])
- print('item ID: ' + exchange_response['item_id'])
+ global access_token
+ global item_id
+ global transfer_id
+ public_token = request.form['public_token']
+ try:
+ exchange_request = ItemPublicTokenExchangeRequest(
+ public_token=public_token)
+ exchange_response = client.item_public_token_exchange(exchange_request)
+ access_token = exchange_response['access_token']
+ item_id = exchange_response['item_id']
+ return jsonify(exchange_response.to_dict())
+ except plaid.ApiException as e:
+ return json.loads(e.body)
+
+
+# Retrieve ACH or ETF account numbers for an Item
+# https://plaid.com/docs/#auth
+
+
+@app.route('/api/auth', methods=['GET'])
+def get_auth():
+ try:
+ request = AuthGetRequest(
+ access_token=access_token
+ )
+ response = client.auth_get(request)
+ pretty_print_response(response.to_dict())
+ return jsonify(response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# Retrieve Transactions for an Item
+# https://plaid.com/docs/#transactions
+
+
+@app.route('/api/transactions', methods=['GET'])
+def get_transactions():
+ # Set cursor to empty to receive all historical updates
+ cursor = ''
+
+ # New transaction updates since "cursor"
+ added = []
+ modified = []
+ removed = [] # Removed transaction ids
+ has_more = True
+ try:
+ # Iterate through each page of new transaction updates for item
+ while has_more:
+ request = TransactionsSyncRequest(
+ access_token=access_token,
+ cursor=cursor,
+ )
+ response = client.transactions_sync(request).to_dict()
+ cursor = response['next_cursor']
+ # If no transactions are available yet, wait and poll the endpoint.
+ # Normally, we would listen for a webhook, but the Quickstart doesn't
+ # support webhooks. For a webhook example, see
+ # https://github.com/plaid/tutorial-resources or
+ # https://github.com/plaid/pattern
+ if cursor == '':
+ time.sleep(2)
+ continue
+ # If cursor is not an empty string, we got results,
+ # so add this page of results
+ added.extend(response['added'])
+ modified.extend(response['modified'])
+ removed.extend(response['removed'])
+ has_more = response['has_more']
+ pretty_print_response(response)
+
+ # Return the 8 most recent transactions
+ latest_transactions = sorted(added, key=lambda t: t['date'])[-8:]
+ return jsonify({
+ 'latest_transactions': latest_transactions})
+
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# Retrieve Identity data for an Item
+# https://plaid.com/docs/#identity
+
+
+@app.route('/api/identity', methods=['GET'])
+def get_identity():
+ try:
+ request = IdentityGetRequest(
+ access_token=access_token
+ )
+ response = client.identity_get(request)
+ pretty_print_response(response.to_dict())
+ return jsonify(
+ {'error': None, 'identity': response.to_dict()['accounts']})
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# Retrieve real-time balance data for each of an Item's accounts
+# https://plaid.com/docs/#balance
+
+
+@app.route('/api/balance', methods=['GET'])
+def get_balance():
+ try:
+ balance_request = AccountsBalanceGetRequest(access_token=access_token)
+ balance_response = client.accounts_balance_get(balance_request)
+ pretty_print_response(balance_response.to_dict())
+ return jsonify(balance_response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# Retrieve an Item's accounts
+# https://plaid.com/docs/#accounts
+
- access_token = exchange_response['access_token']
+@app.route('/api/accounts', methods=['GET'])
+def get_accounts():
+ try:
+ request = AccountsGetRequest(
+ access_token=access_token
+ )
+ response = client.accounts_get(request)
+ pretty_print_response(response.to_dict())
+ return jsonify(response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
- return jsonify(exchange_response)
-@app.route("/accounts", methods=['GET'])
-def accounts():
- global access_token
- accounts = client.Auth.get(access_token)
- return jsonify(accounts)
+# Create and then retrieve an Asset Report for one or more Items. Note that an
+# Asset Report can contain up to 100 items, but for simplicity we're only
+# including one Item here.
+# https://plaid.com/docs/#assets
-@app.route("/item", methods=['GET', 'POST'])
+
+@app.route('/api/assets', methods=['GET'])
+def get_assets():
+ try:
+ request = AssetReportCreateRequest(
+ access_tokens=[access_token],
+ days_requested=60,
+ options=AssetReportCreateRequestOptions(
+ webhook='https://www.example.com',
+ client_report_id='123',
+ user=AssetReportUser(
+ client_user_id='789',
+ 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)
+ pretty_print_response(response.to_dict())
+ asset_report_token = response['asset_report_token']
+
+ # Poll for the completion of the Asset Report.
+ request = AssetReportGetRequest(
+ asset_report_token=asset_report_token,
+ )
+ response = poll_with_retries(lambda: client.asset_report_get(request))
+ asset_report_json = response['report']
+
+ request = AssetReportPDFGetRequest(
+ asset_report_token=asset_report_token,
+ )
+ pdf = client.asset_report_pdf_get(request)
+ return jsonify({
+ 'error': None,
+ 'json': asset_report_json.to_dict(),
+ 'pdf': base64.b64encode(pdf.read()).decode('utf-8'),
+ })
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# Retrieve investment holdings data for an Item
+# https://plaid.com/docs/#investments
+
+
+@app.route('/api/holdings', methods=['GET'])
+def get_holdings():
+ try:
+ request = InvestmentsHoldingsGetRequest(access_token=access_token)
+ response = client.investments_holdings_get(request)
+ pretty_print_response(response.to_dict())
+ return jsonify({'error': None, 'holdings': response.to_dict()})
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# Retrieve Investment Transactions for an Item
+# https://plaid.com/docs/#investments
+
+
+@app.route('/api/investments_transactions', methods=['GET'])
+def get_investments_transactions():
+ # Pull transactions for the last 30 days
+
+ start_date = (dt.datetime.now() - dt.timedelta(days=(30)))
+ end_date = dt.datetime.now()
+ try:
+ options = InvestmentsTransactionsGetRequestOptions()
+ request = InvestmentsTransactionsGetRequest(
+ access_token=access_token,
+ start_date=start_date.date(),
+ end_date=end_date.date(),
+ options=options
+ )
+ response = client.investments_transactions_get(
+ request)
+ pretty_print_response(response.to_dict())
+ return jsonify(
+ {'error': None, 'investments_transactions': response.to_dict()})
+
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+# This functionality is only relevant for the ACH Transfer product.
+# Authorize a transfer
+
+@app.route('/api/transfer_authorize', methods=['GET'])
+def transfer_authorization():
+ global authorization_id
+ global account_id
+ request = AccountsGetRequest(access_token=access_token)
+ response = client.accounts_get(request)
+ account_id = response['accounts'][0]['account_id']
+ try:
+ request = TransferAuthorizationCreateRequest(
+ access_token=access_token,
+ account_id=account_id,
+ type=TransferType('debit'),
+ network=TransferNetwork('ach'),
+ amount='1.00',
+ ach_class=ACHClass('ppd'),
+ user=TransferAuthorizationUserInRequest(
+ legal_name='FirstName LastName',
+ email_address='foobar@email.com',
+ address=TransferUserAddressInRequest(
+ street='123 Main St.',
+ city='San Francisco',
+ region='CA',
+ postal_code='94053',
+ country='US'
+ ),
+ ),
+ )
+ response = client.transfer_authorization_create(request)
+ pretty_print_response(response.to_dict())
+ authorization_id = response['authorization']['id']
+ return jsonify(response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+# Create Transfer for a specified Transfer ID
+
+@app.route('/api/transfer_create', methods=['GET'])
+def transfer():
+ try:
+ request = TransferCreateRequest(
+ access_token=access_token,
+ account_id=account_id,
+ authorization_id=authorization_id,
+ description='Debit')
+ response = client.transfer_create(request)
+ pretty_print_response(response.to_dict())
+ return jsonify(response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+@app.route('/api/statements', methods=['GET'])
+def statements():
+ try:
+ request = StatementsListRequest(access_token=access_token)
+ response = client.statements_list(request)
+ pretty_print_response(response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+ try:
+ request = StatementsDownloadRequest(
+ access_token=access_token,
+ statement_id=response['accounts'][0]['statements'][0]['statement_id']
+ )
+ pdf = client.statements_download(request)
+ return jsonify({
+ 'error': None,
+ 'json': response.to_dict(),
+ 'pdf': base64.b64encode(pdf.read()).decode('utf-8'),
+ })
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+
+
+@app.route('/api/signal_evaluate', methods=['GET'])
+def signal():
+ global account_id
+ request = AccountsGetRequest(access_token=access_token)
+ response = client.accounts_get(request)
+ account_id = response['accounts'][0]['account_id']
+ try:
+ # Generate unique transaction ID using timestamp and random component
+ client_transaction_id = f"txn-{int(time.time() * 1000)}-{uuid.uuid4().hex[:8]}"
+
+ signal_request_params = {
+ 'access_token': access_token,
+ 'account_id': account_id,
+ 'client_transaction_id': client_transaction_id,
+ 'amount': 100.00
+ }
+
+ if SIGNAL_RULESET_KEY:
+ signal_request_params['ruleset_key'] = SIGNAL_RULESET_KEY
+
+ request = SignalEvaluateRequest(**signal_request_params)
+ response = client.signal_evaluate(request)
+ pretty_print_response(response.to_dict())
+ return jsonify(response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# This functionality is only relevant for the UK Payment Initiation product.
+# Retrieve Payment for a specified Payment ID
+
+
+@app.route('/api/payment', methods=['GET'])
+def payment():
+ global payment_id
+ try:
+ request = PaymentInitiationPaymentGetRequest(payment_id=payment_id)
+ response = client.payment_initiation_payment_get(request)
+ pretty_print_response(response.to_dict())
+ return jsonify({'error': None, 'payment': response.to_dict()})
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+
+# Retrieve high-level information about an Item
+# https://plaid.com/docs/#retrieve-item
+
+
+@app.route('/api/item', methods=['GET'])
def item():
- global access_token
- item_response = client.Item.get(access_token)
- institution_response = client.Institutions.get_by_id(item_response['item']['institution_id'])
- return jsonify({'item': item_response['item'], 'institution': institution_response['institution']})
-
-@app.route("/transactions", methods=['GET', 'POST'])
-def transactions():
- global access_token
- # 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:
- response = client.Transactions.get(access_token, start_date, end_date)
- return jsonify(response)
- except plaid.errors.PlaidError as e:
- return jsonify({'error': {'error_code': e.code, 'error_message': str(e)}})
-
-@app.route("/create_public_token", methods=['GET'])
-def create_public_token():
- global access_token
- # Create a one-time use public_token for the Item. This public_token can be used to
- # initialize Link in update mode for the user.
- response = client.Item.public_token.create(access_token)
- return jsonify(response)
-
-if __name__ == "__main__":
- app.run(port=os.getenv('PORT', 5000))
+ try:
+ request = ItemGetRequest(access_token=access_token)
+ response = client.item_get(request)
+ request = InstitutionsGetByIdRequest(
+ institution_id=response['item']['institution_id'],
+ country_codes=list(map(lambda x: CountryCode(x), PLAID_COUNTRY_CODES))
+ )
+ institution_response = client.institutions_get_by_id(request)
+ pretty_print_response(response.to_dict())
+ pretty_print_response(institution_response.to_dict())
+ return jsonify({'error': None, 'item': response.to_dict()[
+ 'item'], 'institution': institution_response.to_dict()['institution']})
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+# Retrieve CRA Base Report and PDF
+# Base report: https://plaid.com/docs/check/api/#cracheck_reportbase_reportget
+# PDF: https://plaid.com/docs/check/api/#cracheck_reportpdfget
+@app.route('/api/cra/get_base_report', methods=['GET'])
+def cra_check_report():
+ try:
+ # Use user_token if available, otherwise use user_id
+ if user_token:
+ base_report_request = CraCheckReportBaseReportGetRequest(user_token=user_token, item_ids=[])
+ elif user_id:
+ base_report_request = CraCheckReportBaseReportGetRequest(user_id=user_id, item_ids=[])
+
+ get_response = poll_with_retries(lambda: client.cra_check_report_base_report_get(base_report_request))
+ pretty_print_response(get_response.to_dict())
+
+ if user_token:
+ pdf_request = CraCheckReportPDFGetRequest(user_token=user_token)
+ elif user_id:
+ pdf_request = CraCheckReportPDFGetRequest(user_id=user_id)
+
+ pdf_response = client.cra_check_report_pdf_get(pdf_request)
+
+ return jsonify({
+ 'report': get_response.to_dict()['report'],
+ 'pdf': base64.b64encode(pdf_response.read()).decode('utf-8')
+ })
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+# Retrieve CRA Income Insights and PDF with Insights
+# Income insights: https://plaid.com/docs/check/api/#cracheck_reportincome_insightsget
+# PDF w/ income insights: https://plaid.com/docs/check/api/#cracheck_reportpdfget
+@app.route('/api/cra/get_income_insights', methods=['GET'])
+def cra_income_insights():
+ try:
+ # Use user_token if available, otherwise use user_id
+ insights_request = {}
+ if user_token:
+ insights_request = CraCheckReportIncomeInsightsGetRequest(user_token=user_token)
+ elif user_id:
+ insights_request = CraCheckReportIncomeInsightsGetRequest(user_id=user_id)
+
+ get_response = poll_with_retries(lambda: client.cra_check_report_income_insights_get(insights_request))
+ pretty_print_response(get_response.to_dict())
+
+ pdf_request = {}
+ if user_token:
+ pdf_request = CraCheckReportPDFGetRequest(user_token=user_token, add_ons=[CraPDFAddOns('cra_income_insights')])
+ elif user_id:
+ pdf_request = CraCheckReportPDFGetRequest(user_id=user_id, add_ons=[CraPDFAddOns('cra_income_insights')])
+
+ pdf_response = client.cra_check_report_pdf_get(pdf_request)
+
+ return jsonify({
+ 'report': get_response.to_dict()['report'],
+ 'pdf': base64.b64encode(pdf_response.read()).decode('utf-8')
+ })
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+# Retrieve CRA Partner Insights
+# https://plaid.com/docs/check/api/#cracheck_reportpartner_insightsget
+@app.route('/api/cra/get_partner_insights', methods=['GET'])
+def cra_partner_insights():
+ try:
+ # Use user_token if available, otherwise use user_id
+ if user_token:
+ partner_request = CraCheckReportPartnerInsightsGetRequest(user_token=user_token)
+ elif user_id:
+ partner_request = CraCheckReportPartnerInsightsGetRequest(user_id=user_id)
+
+ response = poll_with_retries(lambda: client.cra_check_report_partner_insights_get(partner_request))
+ pretty_print_response(response.to_dict())
+
+ return jsonify(response.to_dict())
+ except plaid.ApiException as e:
+ error_response = format_error(e)
+ return jsonify(error_response)
+
+# Since this quickstart does not support webhooks, this function can be used to poll
+# an API that would otherwise be triggered by a webhook.
+# For a webhook example, see
+# https://github.com/plaid/tutorial-resources or
+# https://github.com/plaid/pattern
+def poll_with_retries(request_callback, ms=1000, retries_left=20):
+ while retries_left > 0:
+ try:
+ return request_callback()
+ except plaid.ApiException as e:
+ response = json.loads(e.body)
+ if response['error_code'] != 'PRODUCT_NOT_READY':
+ raise e
+ elif retries_left == 0:
+ raise Exception('Ran out of retries while polling') from e
+ else:
+ retries_left -= 1
+ time.sleep(ms / 1000)
+
+def pretty_print_response(response):
+ print(json.dumps(response, indent=2, sort_keys=True, default=str))
+
+def format_error(e):
+ response = json.loads(e.body)
+ return {'error': {'status_code': e.status, 'display_message':
+ response['error_message'], 'error_code': response['error_code'], 'error_type': response['error_type']}}
+
+if __name__ == '__main__':
+ app.run(port=int(os.getenv('PORT', 8000)))
diff --git a/python/start.sh b/python/start.sh
new file mode 100755
index 000000000..0cce0cda3
--- /dev/null
+++ b/python/start.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+python server.py || python3 server.py
\ No newline at end of file
diff --git a/python/static/style.css b/python/static/style.css
deleted file mode 100644
index caeea4798..000000000
--- a/python/static/style.css
+++ /dev/null
@@ -1,51 +0,0 @@
-html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, font, img, kbd, q, s, samp,
-small, strike, sub, sup, tt, var, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td {
-margin: 0; padding: 0; border: 0; outline: 0; font-weight: inherit; font-style: inherit; font-size: 100%; font-family: inherit; vertical-align: baseline; }
-:focus { outline: 0; }
-body { line-height: 1; }
-
-html {
- color: #444;
- font: normal 62.5%/1 helvetica, arial, sans-serif;
- padding: 0px;
- margin: 0;
- text-align: center;
- background: #f9f9f9;
-}
-
-body {
- padding: 0px;
- margin: 0px;
- text-align: center;
-}
-
-a, a:visited { color: #3a98c9; text-decoration: none; }
-a:hover { text-decoration: underline; }
-
-#banner, #container, .box { min-width: 280px; max-width: 800px; margin: 20px auto 0; padding: 20px; background: #fff; border: 1px solid #c9c9c9; border-radius: 2px; text-align: left; }
-#container p { font-size: 14px; line-height: 17px; margin-bottom: 20px; }
-button {
- background-color: #1a476a;
- background-image: -webkit-linear-gradient(top, #29618e, #164a74);
- background-image: linear-gradient(to bottom, #29618e, #164a74);
- border-color: #1a476a;
- border-style: solid;
- border-width: 1px;
- box-shadow: inset 0 1px 2px rgba(255,255,255,0.1),0 1px 2px rgba(19,49,69,0.2);
- color: #fff;
- text-shadow: 0 2px 4px rgba(0,0,0,0.1);
- padding: 10px 30px;
- font-size: 18px;
- border-radius: 4px;
-}
-button:hover { color: #f1f1f1; cursor: pointer; }
-
-#app { display: none; }
-#app textarea { display: none; height: 100px; width: 260px; padding: 10px; font-size: 14px; }
-.box { margin: 20px auto 0; }
-.inner { background: #f3f3f3; font-size: 14px; line-height: 17px; padding: 20px; border-radius: 2px; margin-top: 20px; }
-#banner { border-top: 0px; margin-top: 0px; border-radius: 0 0 2px 2px; }
-#banner h1 { color: #1a476a; font-size: 18px; font-weight: bold; }
-#banner p { font-size: 14px; line-height: 17px; margin-top: 5px; }
-#steps { display: none; }
-.green { background: #3ab683; color: #fff; }
diff --git a/python/templates/index.ejs b/python/templates/index.ejs
deleted file mode 100644
index 4dad83857..000000000
--- a/python/templates/index.ejs
+++ /dev/null
@@ -1,152 +0,0 @@
-
-
-
-
- Plaid Walkthrough Example
-
-
-
-
-
-
Plaid Example Walkthrough
-
- This is an example application that walks through integrating Plaid Link using the API to retrieve Auth and Transaction data.
-
-
- Great - you just created an Item! The server was successfully able to exchange the public_token for an access_token.
- Below are a few options - you can get account data, retrieve information about the Item itself, or pull transaction data.
-
-
-
-
-
- Click the button below to open a list of Institutions - after you select one,
- you'll be guided through an authentication process. The public_token will be passed
- back to the example server, which will then exchange it for an access_token and log it
- to your console.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/ruby/.env b/ruby/.env
new file mode 120000
index 000000000..4a82335f5
--- /dev/null
+++ b/ruby/.env
@@ -0,0 +1 @@
+../.env
\ No newline at end of file
diff --git a/ruby/.env.example b/ruby/.env.example
new file mode 120000
index 000000000..821f01742
--- /dev/null
+++ b/ruby/.env.example
@@ -0,0 +1 @@
+../.env.example
\ No newline at end of file
diff --git a/ruby/.gitignore b/ruby/.gitignore
new file mode 100644
index 000000000..ef7f0cebe
--- /dev/null
+++ b/ruby/.gitignore
@@ -0,0 +1,2 @@
+bin
+.bundle
diff --git a/ruby/.ruby-version b/ruby/.ruby-version
new file mode 100644
index 000000000..be94e6f53
--- /dev/null
+++ b/ruby/.ruby-version
@@ -0,0 +1 @@
+3.2.2
diff --git a/ruby/Dockerfile b/ruby/Dockerfile
new file mode 100644
index 000000000..e384db325
--- /dev/null
+++ b/ruby/Dockerfile
@@ -0,0 +1,12 @@
+FROM ruby:3.3.10
+
+WORKDIR /opt/app
+COPY . .
+WORKDIR /opt/app/ruby
+
+RUN bundle update --bundler
+RUN bundle install
+
+EXPOSE 8000
+ENTRYPOINT ["ruby"]
+CMD ["app.rb", "-o", "0.0.0.0"]
diff --git a/ruby/Gemfile b/ruby/Gemfile
index 82118dc3c..c40bf56cd 100644
--- a/ruby/Gemfile
+++ b/ruby/Gemfile
@@ -1,4 +1,14 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
-gem 'sinatra'
-gem 'plaid'
+gem 'sinatra', '~> 4.2'
+
+gem 'http', '~> 5.0'
+
+gem "dotenv", "~> 3.1"
+
+gem "plaid", "= 45.1.0"
+
+gem "webrick", "~> 1.8"
+
+gem "rackup", "~> 2.2"
+gem "puma", "~> 7.1"
diff --git a/ruby/Gemfile.lock b/ruby/Gemfile.lock
new file mode 100644
index 000000000..cdac4d38a
--- /dev/null
+++ b/ruby/Gemfile.lock
@@ -0,0 +1,82 @@
+GEM
+ remote: https://rubygems.org/
+ specs:
+ addressable (2.8.8)
+ public_suffix (>= 2.0.2, < 8.0)
+ base64 (0.3.0)
+ domain_name (0.6.20240107)
+ dotenv (3.2.0)
+ faraday (2.14.1)
+ faraday-net_http (>= 2.0, < 3.5)
+ json
+ logger
+ faraday-multipart (1.2.0)
+ multipart-post (~> 2.0)
+ faraday-net_http (3.4.2)
+ net-http (~> 0.5)
+ ffi (1.17.3)
+ ffi-compiler (1.3.2)
+ ffi (>= 1.15.5)
+ rake
+ http (5.3.1)
+ addressable (~> 2.8)
+ http-cookie (~> 1.0)
+ http-form_data (~> 2.2)
+ llhttp-ffi (~> 0.5.0)
+ http-cookie (1.1.0)
+ domain_name (~> 0.5)
+ http-form_data (2.3.0)
+ json (2.18.1)
+ llhttp-ffi (0.5.1)
+ ffi-compiler (~> 1.0)
+ rake (~> 13.0)
+ logger (1.7.0)
+ multipart-post (2.4.1)
+ mustermann (3.0.4)
+ ruby2_keywords (~> 0.0.1)
+ net-http (0.9.1)
+ uri (>= 0.11.1)
+ nio4r (2.7.5)
+ plaid (45.1.0)
+ faraday (>= 1.0.1, < 3.0)
+ faraday-multipart (>= 1.0.1, < 2.0)
+ public_suffix (7.0.2)
+ puma (7.2.0)
+ nio4r (~> 2.0)
+ rack (3.2.5)
+ rack-protection (4.2.1)
+ base64 (>= 0.1.0)
+ logger (>= 1.6.0)
+ rack (>= 3.0.0, < 4)
+ rack-session (2.1.1)
+ base64 (>= 0.1.0)
+ rack (>= 3.0.0)
+ rackup (2.3.1)
+ rack (>= 3)
+ rake (13.3.1)
+ ruby2_keywords (0.0.5)
+ sinatra (4.2.1)
+ logger (>= 1.6.0)
+ mustermann (~> 3.0)
+ rack (>= 3.0.0, < 4)
+ rack-protection (= 4.2.1)
+ rack-session (>= 2.0.0, < 3)
+ tilt (~> 2.0)
+ tilt (2.7.0)
+ uri (1.1.1)
+ webrick (1.9.2)
+
+PLATFORMS
+ ruby
+
+DEPENDENCIES
+ dotenv (~> 3.1)
+ http (~> 5.0)
+ plaid (= 45.1.0)
+ puma (~> 7.1)
+ rackup (~> 2.2)
+ sinatra (~> 4.2)
+ webrick (~> 1.8)
+
+BUNDLED WITH
+ 2.4.10
diff --git a/ruby/README.md b/ruby/README.md
deleted file mode 100644
index 7d25cc961..000000000
--- a/ruby/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-### plaid-ruby quickstart
-
-[Quickstart guide](https://plaid.com/docs/quickstart)
-
-``` bash
-git clone https://github.com/plaid/quickstart.git
-cd quickstart/ruby
-
-# Install dependencies
-bundle
-
-# Start the sample app using your API keys available from the Dashboard:
-# https://dashboard.plaid.com
-PLAID_CLIENT_ID=[CLIENT_ID] \
-PLAID_SECRET=[SECRET] \
-PLAID_PUBLIC_KEY=[PUBLIC_KEY] \
-ruby app.rb
-# Go to http://localhost:4567
-```
diff --git a/ruby/app.rb b/ruby/app.rb
index 3438ab418..0fd8b3875 100644
--- a/ruby/app.rb
+++ b/ruby/app.rb
@@ -1,56 +1,875 @@
+# Load env vars from .env file
+require 'dotenv'
+Dotenv.load
+
+require 'base64'
require 'date'
-require 'sinatra'
+require 'json'
require 'plaid'
+require 'securerandom'
+require 'sinatra'
+
+set :port, ENV['APP_PORT'] || 8000
+
+# disable CSRF warning and Rack protection on localhost due to usage of local /api proxy in react app.
+# delete this for a production application.
+set :protection, :except => [:json_csrf]
+set :host_authorization, { permitted_hosts: [] }
-set :public_folder, File.dirname(__FILE__) + '/public'
+configuration = Plaid::Configuration.new
+configuration.server_index = Plaid::Configuration::Environment[ENV['PLAID_ENV'] || 'sandbox']
+configuration.api_key['PLAID-CLIENT-ID'] = ENV['PLAID_CLIENT_ID']
+configuration.api_key['PLAID-SECRET'] = ENV['PLAID_SECRET']
+configuration.api_key['Plaid-Version'] = '2020-09-14'
-client = Plaid::Client.new(env: :sandbox,
- client_id: ENV['PLAID_CLIENT_ID'],
- secret: ENV['PLAID_SECRET'],
- public_key: ENV['PLAID_PUBLIC_KEY'])
+api_client = Plaid::ApiClient.new(
+ configuration
+)
+client = Plaid::PlaidApi.new(api_client)
+products = ENV['PLAID_PRODUCTS'].split(',')
+# We store the access_token, user_token, and user_id in memory - in production, store it in a secure
+# persistent data store.
access_token = nil
+user_token = nil
+user_id = nil
+# The payment_id is only relevant for the UK Payment Initiation product.
+# We store the payment_token in memory - in production, store it in a secure
+# persistent data store.
-get '/' do
- erb :index
-end
+payment_id = nil
+item_id = nil
-post '/get_access_token' do
- exchange_token_response = client.item.public_token.exchange(params['public_token'])
- access_token = exchange_token_response['access_token']
- item_id = exchange_token_response['item_id']
- puts "access token: #{access_token}"
- puts "item id: #{item_id}"
- exchange_token_response.to_json
-end
+# The authorization_id is only relevant for Transfer ACH product.
+# We store the authorization_id in memory - in production, store it in a secure
+# persistent data store.
+authorization_id = nil
+account_id = nil
-get '/accounts' do
- auth_response = client.auth.get(access_token)
+post '/api/info' do
content_type :json
- auth_response.to_json
+ {
+ item_id: item_id,
+ access_token: access_token,
+ products: ENV['PLAID_PRODUCTS'].split(','),
+ }.to_json
end
-get '/item' do
- item_response = client.item.get(access_token)
- institution_response = client.institutions.get_by_id(item_response['item']['institution_id'])
+# Exchange token flow - exchange a Link public_token for
+# an API access_token
+# https://plaid.com/docs/#exchange-token-flow
+post '/api/set_access_token' do
+ item_public_token_exchange_request = Plaid::ItemPublicTokenExchangeRequest.new(
+ { public_token: params['public_token'] }
+ )
+ exchange_token_response =
+ client.item_public_token_exchange(
+ item_public_token_exchange_request
+ )
+ access_token = exchange_token_response.access_token
+ item_id = exchange_token_response.item_id
+ pretty_print_response(exchange_token_response.to_hash)
content_type :json
- { item: item_response['item'], institution: institution_response['institution'] }.to_json
+ exchange_token_response.to_hash.to_json
+end
+
+# Retrieve Transactions for an Item
+# https://plaid.com/docs/#transactions
+get '/api/transactions' do
+ begin
+ # Set cursor to empty to receive all historical updates
+ cursor = ''
+
+ # New transaction updates since "cursor"
+ added = []
+ modified = []
+ removed = [] # Removed transaction ids
+ has_more = true
+ # Iterate through each page of new transaction updates for item
+ while has_more
+ request = Plaid::TransactionsSyncRequest.new(
+ {
+ access_token: access_token,
+ cursor: cursor
+ }
+ )
+ response = client.transactions_sync(request)
+ cursor = response.next_cursor
+
+ # If no transactions are available yet, wait and poll the endpoint.
+ # Normally, we would listen for a webhook but the Quickstart doesn't
+ # support webhooks. For a webhook example, see
+ # https://github.com/plaid/tutorial-resources or
+ # https://github.com/plaid/pattern
+ if cursor == ""
+ sleep 2
+ next
+ end
+
+ # Add this page of results
+ added += response.added
+ modified += response.modified
+ removed += response.removed
+ has_more = response.has_more
+ pretty_print_response(response.to_hash)
+ end
+ # Return the 8 most recent transactions
+ content_type :json
+ { latest_transactions: added.sort_by(&:date).last(8).map(&:to_hash) }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# Retrieve ACH or ETF account numbers for an Item
+# https://plaid.com/docs/#auth
+get '/api/auth' do
+ begin
+ auth_get_request = Plaid::AuthGetRequest.new({ access_token: access_token })
+ auth_response = client.auth_get(auth_get_request)
+ pretty_print_response(auth_response.to_hash)
+ content_type :json
+ auth_response.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# Retrieve Identity data for an Item
+# https://plaid.com/docs/#identity
+get '/api/identity' do
+ begin
+ identity_get_request = Plaid::IdentityGetRequest.new({ access_token: access_token })
+ identity_response = client.identity_get(identity_get_request)
+ pretty_print_response(identity_response.to_hash)
+ content_type :json
+ { identity: identity_response.to_hash[:accounts] }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# Retrieve real-time balance data for each of an Item's accounts
+# https://plaid.com/docs/#balance
+get '/api/balance' do
+ begin
+ balance_request = Plaid::AccountsBalanceGetRequest.new({ access_token: access_token })
+ balance_response = client.accounts_balance_get(balance_request)
+ pretty_print_response(balance_response.to_hash)
+ content_type :json
+ balance_response.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# Retrieve an Item's accounts
+# https://plaid.com/docs/#accounts
+get '/api/accounts' do
+ begin
+ accounts_get_request = Plaid::AccountsGetRequest.new({ access_token: access_token })
+ account_response = client.accounts_get(accounts_get_request)
+ pretty_print_response(account_response.to_hash)
+ content_type :json
+ account_response.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# Retrieve Holdings data for an Item
+# https://plaid.com/docs/#investments
+get '/api/holdings' do
+ begin
+ investments_holdings_get_request = Plaid::InvestmentsHoldingsGetRequest.new({ access_token: access_token })
+ product_response = client.investments_holdings_get(investments_holdings_get_request)
+ pretty_print_response(product_response.to_hash)
+ content_type :json
+ { holdings: product_response.to_hash }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_hash.to_json
+ end
end
-get '/transactions' do
- now = Date.today
- thirty_days_ago = (now - 30)
+# Retrieve Investment Transactions for an Item
+# https://plaid.com/docs/#investments
+get '/api/investments_transactions' do
begin
- transactions_response = client.transactions.get(access_token, thirty_days_ago, now)
- rescue Plaid::ItemError => e
- transactions_response = { error: {error_code: e.error_code, error_message: e.error_message}}
+ start_date = (Date.today - 30)
+ end_date = Date.today
+ investments_transactions_get_request = Plaid::InvestmentsTransactionsGetRequest.new(
+ {
+ access_token: access_token,
+ start_date: start_date,
+ end_date: end_date
+ }
+ )
+ transactions_response = client.investments_transactions_get(investments_transactions_get_request)
+ pretty_print_response(transactions_response.to_hash)
+ content_type :json
+ { investments_transactions: transactions_response.to_hash }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
end
+end
+
+# Create and then retrieve an Asset Report for one or more Items. Note that an
+# Asset Report can contain up to 100 items, but for simplicity we're only
+# including one Item here.
+# https://plaid.com/docs/#assets
+# rubocop:disable Metrics/BlockLength
+get '/api/assets' do
+ begin
+ options = {
+ client_report_id: '123',
+ webhook: 'https://www.example.com',
+ user: {
+ client_user_id: '789',
+ first_name: 'Jane',
+ middle_name: 'Leah',
+ last_name: 'Doe',
+ ssn: '123-45-6789',
+ phone_number: '(555) 123-4567',
+ email: 'jane.doe@example.com'
+ }
+ }
+ asset_report_create_request = Plaid::AssetReportCreateRequest.new(
+ {
+ access_tokens: [access_token],
+ days_requested: 20,
+ options: options
+ }
+ )
+ asset_report_create_response =
+ client.asset_report_create(asset_report_create_request)
+ pretty_print_response(asset_report_create_response.to_hash)
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+
+ asset_report_token = asset_report_create_response.asset_report_token
+ asset_report_json = nil
+ num_retries_remaining = 20
+ while num_retries_remaining.positive?
+ begin
+ asset_report_get_request = Plaid::AssetReportGetRequest.new({ asset_report_token: asset_report_token })
+ asset_report_get_response = client.asset_report_get(asset_report_get_request)
+ asset_report_json = asset_report_get_response.report
+ break
+ rescue Plaid::ApiError => e
+ json_response = JSON.parse(e.response_body)
+ if json_response['error_code'] == 'PRODUCT_NOT_READY'
+ num_retries_remaining -= 1
+ sleep(1)
+ next
+ end
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ return error_response.to_json
+ end
+ end
+
+ if asset_report_json.nil?
+ content_type :json
+ return {
+ error: {
+ error_code: 0,
+ error_message: 'Timed out when polling for Asset Report'
+ }
+ }.to_json
+ end
+
+ asset_report_pdf_get_request = Plaid::AssetReportPDFGetRequest.new({ asset_report_token: asset_report_token })
+ asset_report_pdf = client.asset_report_pdf_get( asset_report_pdf_get_request)
+
content_type :json
- transactions_response.to_json
+ { json: asset_report_json.to_hash,
+ pdf: Base64.encode64(File.read(asset_report_pdf)) }.to_json
end
-get '/create_public_token' do
- public_token_response = client.item.public_token.exchange(access_token)
+get '/api/statements' do
+ begin
+ statements_list_request = Plaid::StatementsListRequest.new(
+ {
+ access_token: access_token
+ }
+ )
+ statements_list_response =
+ client.statements_list(statements_list_request)
+ pretty_print_response(statements_list_response.to_hash)
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+ statement_id = statements_list_response.accounts[0].statements[0].statement_id
+ statements_download_request = Plaid::StatementsDownloadRequest.new({ access_token: access_token, statement_id: statement_id })
+ statement_pdf = client.statements_download(statements_download_request)
+
content_type :json
- public_token_response.to_json
+ { json: statements_list_response.to_hash,
+ pdf: Base64.encode64(File.read(statement_pdf)) }.to_json
+end
+
+# rubocop:enable Metrics/BlockLength
+
+# Retrieve high-level information about an Item
+# https://plaid.com/docs/#retrieve-item
+get '/api/item' do
+ begin
+ item_get_request = Plaid::ItemGetRequest.new({ access_token: access_token})
+ item_response = client.item_get(item_get_request)
+ institutions_get_by_id_request = Plaid::InstitutionsGetByIdRequest.new(
+ {
+ institution_id: item_response.item.institution_id,
+ country_codes: ['US']
+ }
+ )
+ institution_response =
+ client.institutions_get_by_id(institutions_get_by_id_request)
+ pretty_print_response(item_response.to_hash)
+ pretty_print_response(institution_response.to_hash)
+ content_type :json
+ { item: item_response.item.to_hash,
+ institution: institution_response.institution.to_hash }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# This functionality is only relevant for the ACH Transfer product.
+# Retrieve Transfer for a specified Transfer ID
+
+get '/api/transfer_authorize' do
+ begin
+ # We call /accounts/get to obtain first account_id - in production,
+ # account_id's should be persisted in a data store and retrieved
+ # from there.
+ accounts_get_request = Plaid::AccountsGetRequest.new({ access_token: access_token })
+ accounts_get_response = client.accounts_get(accounts_get_request)
+ account_id = accounts_get_response.accounts[0].account_id
+
+ transfer_authorization_create_request = Plaid::TransferAuthorizationCreateRequest.new({
+ access_token: access_token,
+ account_id: account_id,
+ type: 'debit',
+ network: 'ach',
+ amount: '1.00',
+ ach_class: 'ppd',
+ user: {
+ legal_name: 'FirstName LastName',
+ email_address: 'foobar@email.com',
+ address: {
+ street: '123 Main St.',
+ city: 'San Francisco',
+ region: 'CA',
+ postal_code: '94053',
+ country: 'US'
+ }
+ },
+ })
+ transfer_authorization_create_response = client.transfer_authorization_create(transfer_authorization_create_request)
+ pretty_print_response(transfer_authorization_create_response.to_hash)
+ authorization_id = transfer_authorization_create_response.authorization.id
+ content_type :json
+ transfer_authorization_create_response.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+get '/api/signal_evaluate' do
+ begin
+ # We call /accounts/get to obtain first account_id - in production,
+ # account_id's should be persisted in a data store and retrieved
+ # from there.
+ accounts_get_request = Plaid::AccountsGetRequest.new({ access_token: access_token })
+ accounts_get_response = client.accounts_get(accounts_get_request)
+ account_id = accounts_get_response.accounts[0].account_id
+
+ # Generate unique transaction ID using timestamp and random component
+ client_transaction_id = "txn-#{Time.now.to_i}-#{SecureRandom.hex(4)}"
+
+ signal_request_params = {
+ access_token: access_token,
+ account_id: account_id,
+ client_transaction_id: client_transaction_id,
+ amount: 100.00
+ }
+
+ if ENV['SIGNAL_RULESET_KEY'] && !ENV['SIGNAL_RULESET_KEY'].empty?
+ signal_request_params[:ruleset_key] = ENV['SIGNAL_RULESET_KEY']
+ end
+
+ signal_evaluate_request = Plaid::SignalEvaluateRequest.new(signal_request_params)
+ signal_evaluate_response = client.signal_evaluate(signal_evaluate_request)
+ pretty_print_response(signal_evaluate_response.to_hash)
+ content_type :json
+ signal_evaluate_response.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+get '/api/transfer_create' do
+ begin
+ transfer_create_request = Plaid::TransferCreateRequest.new({
+ access_token: access_token,
+ account_id: account_id,
+ authorization_id: authorization_id,
+ description: 'Debit'
+ })
+ transfer_create_response = client.transfer_create(transfer_create_request)
+ pretty_print_response(transfer_create_response.to_hash)
+ content_type :json
+ transfer_create_response.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# This functionality is only relevant for the UK Payment Initiation product.
+# Retrieve Payment for a specified Payment ID
+get '/api/payment' do
+ begin
+ payment_initiation_payment_get_request = Plaid::PaymentInitiationPaymentGetRequest.new({ payment_id: payment_id})
+ payment_get_response = client.payment_initiation_payment_get(payment_initiation_payment_get_request)
+ pretty_print_response(payment_get_response.to_hash)
+ content_type :json
+ { payment: payment_get_response.to_hash}.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+post '/api/create_link_token' do
+ begin
+ link_token_create_request = Plaid::LinkTokenCreateRequest.new(
+ {
+ user: { client_user_id: 'user-id' },
+ client_name: 'Plaid Quickstart',
+ products: ENV['PLAID_PRODUCTS'].split(','),
+ country_codes: ENV['PLAID_COUNTRY_CODES'].split(','),
+ language: 'en',
+ redirect_uri: nil_if_empty_envvar('PLAID_REDIRECT_URI')
+ }
+ )
+ if ENV['PLAID_PRODUCTS'].split(',').include?("statements")
+ today = Date.today
+ statements = Plaid::LinkTokenCreateRequestStatements.new(
+ end_date: today,
+ start_date: today-30
+ )
+ link_token_create_request.statements=statements
+ end
+ if products.any? { |product| product.start_with?("cra_") }
+ link_token_create_request.cra_options = Plaid::LinkTokenCreateRequestCraOptions.new(
+ days_requested: 60
+ )
+ # Use user_token if available, otherwise use user_id
+ if user_token
+ link_token_create_request.user_token = user_token
+ # Keep user object when using user_token
+ elsif user_id
+ link_token_create_request.user_id = user_id
+ # Remove user object when using user_id
+ link_token_create_request.user = nil
+ end
+ link_token_create_request.consumer_report_permissible_purpose = Plaid::ConsumerReportPermissiblePurpose::ACCOUNT_REVIEW_CREDIT
+ end
+ link_response = client.link_token_create(link_token_create_request)
+ pretty_print_response(link_response.to_hash)
+ content_type :json
+ { link_token: link_response.link_token }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# Create a user token which can be used for Plaid Check, Income, or Multi-Item link flows
+# https://plaid.com/docs/api/users/#usercreate
+post '/api/create_user_token' do
+ begin
+ client_user_id = 'user_' + SecureRandom.uuid
+
+ request_data = {
+ # Typically this will be a user ID number from your application.
+ client_user_id: client_user_id
+ }
+
+ if products.any? { |product| product.start_with?("cra_") }
+ # Try with Identity field first (new-style)
+ request_data[:identity] = {
+ name: {
+ given_name: 'Harry',
+ family_name: 'Potter'
+ },
+ date_of_birth: '1980-07-31',
+ phone_numbers: [{
+ data: '+16174567890',
+ primary: true
+ }],
+ emails: [{
+ data: 'harrypotter@example.com',
+ primary: true
+ }],
+ addresses: [{
+ street_1: '4 Privet Drive',
+ city: 'New York',
+ region: 'NY',
+ postal_code: '11111',
+ country: 'US',
+ primary: true
+ }]
+ }
+ end
+
+ begin
+ user = client.user_create(Plaid::UserCreateRequest.new(request_data))
+ # Store both user_token and user_id
+ user_token = user.user_token if user.user_token
+ user_id = user.user_id if user.user_id
+ content_type :json
+ user.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_body = JSON.parse(e.response_body) rescue {}
+ if error_body['error_code'] == 'INVALID_FIELD' &&
+ products.any? { |product| product.start_with?("cra_") }
+ retry_request_data = {
+ client_user_id: client_user_id,
+ consumer_report_user_identity: {
+ first_name: 'Harry',
+ last_name: 'Potter',
+ date_of_birth: '1980-07-31',
+ phone_numbers: ['+16174567890'],
+ emails: ['harrypotter@example.com'],
+ primary_address: {
+ city: 'New York',
+ region: 'NY',
+ street: '4 Privet Drive',
+ postal_code: '11111',
+ country: 'US'
+ }
+ }
+ }
+ user = client.user_create(Plaid::UserCreateRequest.new(retry_request_data))
+ # Store both user_token and user_id
+ user_token = user.user_token if user.user_token
+ user_id = user.user_id if user.user_id
+ content_type :json
+ user.to_hash.to_json
+ else
+ raise e
+ end
+ end
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+def nil_if_empty_envvar(field)
+ val = ENV[field]
+ puts "val #{val}"
+ if !val.nil? && val.length > 0
+ return val
+ else
+ return nil
+ end
+end
+
+# This functionality is only relevant for the UK/EU Payment Initiation product.
+# Sets the payment token in memory on the server side. We generate a new
+# payment token so that the developer is not required to supply one.
+# This makes the quickstart easier to use.
+# See:
+# - https://plaid.com/docs/payment-initiation/
+# - https://plaid.com/docs/#payment-initiation-create-link-token-request
+post '/api/create_link_token_for_payment' do
+ begin
+ payment_initiation_recipient_create_request = Plaid::PaymentInitiationRecipientCreateRequest.new(
+ {
+ name: 'Bruce Wayne',
+ iban: 'GB33BUKB20201555555555',
+ address: {
+ street: ['686 Bat Cave Lane'],
+ city: 'Gotham',
+ postal_code: '99999',
+ country: 'GB',
+ },
+ bacs: {
+ account: '26207729',
+ sort_code: '560029',
+ }
+ }
+ )
+ create_recipient_response = client.payment_initiation_recipient_create(
+ payment_initiation_recipient_create_request
+ )
+ recipient_id = create_recipient_response.recipient_id
+
+ payment_initiation_recipient_get_request = Plaid::PaymentInitiationRecipientGetRequest.new(
+ {
+ recipient_id: recipient_id
+ }
+ )
+ get_recipient_response = client.payment_initiation_recipient_get(
+ payment_initiation_recipient_get_request
+ )
+
+ payment_initiation_payment_create_request = Plaid::PaymentInitiationPaymentCreateRequest.new(
+ {
+ recipient_id: recipient_id,
+ reference: 'testpayment',
+ amount: {
+ value: 100.00,
+ currency: 'GBP'
+ }
+ }
+ )
+ create_payment_response = client.payment_initiation_payment_create(
+ payment_initiation_payment_create_request
+ )
+ payment_id = create_payment_response.payment_id
+
+ link_token_create_request = Plaid::LinkTokenCreateRequest.new(
+ {
+ client_name: 'Plaid Quickstart',
+ user: {
+ # This should correspond to a unique id for the current user.
+ # Typically, this will be a user ID number from your application.
+ # Personally identifiable information, such as an email address or phone number, should not be used here.
+ client_user_id: 'user-id'
+ },
+
+ # Institutions from all listed countries will be shown.
+ country_codes: ENV['PLAID_COUNTRY_CODES'].split(','),
+ language: 'en',
+
+ # The 'payment_initiation' product has to be the only element in the 'products' list.
+ products: ['payment_initiation'],
+
+ payment_initiation: {
+ payment_id: payment_id
+ },
+ redirect_uri: nil_if_empty_envvar('PLAID_REDIRECT_URI')
+ }
+ )
+ link_response = client.link_token_create(link_token_create_request)
+ pretty_print_response(link_response.to_hash)
+ content_type :json
+ { link_token: link_response.link_token }.to_hash.to_json
+
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+# Retrieve CRA Base Report and PDF
+# Base report: https://plaid.com/docs/check/api/#cracheck_reportbase_reportget
+# PDF: https://plaid.com/docs/check/api/#cracheck_reportpdfget
+get '/api/cra/get_base_report' do
+ begin
+ get_response = get_cra_base_report_with_retries(client, user_token, user_id)
+ pretty_print_response(get_response.to_hash)
+
+ # Use user_token if available, otherwise use user_id
+ pdf_params = {}
+ if user_token
+ pdf_params[:user_token] = user_token
+ elsif user_id
+ pdf_params[:user_id] = user_id
+ end
+ pdf_response = client.cra_check_report_pdf_get(
+ Plaid::CraCheckReportPDFGetRequest.new(pdf_params)
+ )
+
+ content_type :json
+ {
+ report: get_response.report.to_hash,
+ pdf: Base64.encode64(File.read(pdf_response))
+ }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+def get_cra_base_report_with_retries(plaid_client, user_token, user_id)
+ poll_with_retries do
+ # Use user_token if available, otherwise use user_id
+ params = {}
+ if user_token
+ params[:user_token] = user_token
+ elsif user_id
+ params[:user_id] = user_id
+ end
+ plaid_client.cra_check_report_base_report_get(
+ Plaid::CraCheckReportBaseReportGetRequest.new(params)
+ )
+ end
+end
+
+# Retrieve CRA Income Insights and PDF with Insights
+# Income insights: https://plaid.com/docs/check/api/#cracheck_reportincome_insightsget
+# PDF w/ income insights: https://plaid.com/docs/check/api/#cracheck_reportpdfget
+get '/api/cra/get_income_insights' do
+ begin
+ get_response = get_income_insights_with_retries(client, user_token, user_id)
+ pretty_print_response(get_response.to_hash)
+
+ # Use user_token if available, otherwise use user_id
+ pdf_params = { add_ons: [Plaid::CraPDFAddOns::INCOME_INSIGHTS] }
+ if user_token
+ pdf_params[:user_token] = user_token
+ elsif user_id
+ pdf_params[:user_id] = user_id
+ end
+ pdf_response = client.cra_check_report_pdf_get(
+ Plaid::CraCheckReportPDFGetRequest.new(pdf_params)
+ )
+
+ content_type :json
+ {
+ report: get_response.report.to_hash,
+ pdf: Base64.encode64(File.read(pdf_response))
+ }.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+def get_income_insights_with_retries(plaid_client, user_token, user_id)
+ poll_with_retries do
+ # Use user_token if available, otherwise use user_id
+ params = {}
+ if user_token
+ params[:user_token] = user_token
+ elsif user_id
+ params[:user_id] = user_id
+ end
+ plaid_client.cra_check_report_income_insights_get(
+ Plaid::CraCheckReportIncomeInsightsGetRequest.new(params)
+ )
+ end
+end
+
+# Retrieve CRA Partner Insights
+# https://plaid.com/docs/check/api/#cracheck_reportpartner_insightsget
+get '/api/cra/get_partner_insights' do
+ begin
+ response = get_check_partner_insights_with_retries(client, user_token, user_id)
+ pretty_print_response(response.to_hash)
+
+ content_type :json
+ response.to_hash.to_json
+ rescue Plaid::ApiError => e
+ error_response = format_error(e)
+ pretty_print_response(error_response)
+ content_type :json
+ error_response.to_json
+ end
+end
+
+def get_check_partner_insights_with_retries(plaid_client, user_token, user_id)
+ poll_with_retries do
+ # Use user_token if available, otherwise use user_id
+ params = {}
+ if user_token
+ params[:user_token] = user_token
+ elsif user_id
+ params[:user_id] = user_id
+ end
+ plaid_client.cra_check_report_partner_insights_get(
+ Plaid::CraCheckReportPartnerInsightsGetRequest.new(params)
+ )
+ end
+end
+
+# Since this quickstart does not support webhooks, this function can be used to poll
+# an API that would otherwise be triggered by a webhook.
+# For a webhook example, see
+# https://github.com/plaid/tutorial-resources or
+# https://github.com/plaid/pattern
+def poll_with_retries(ms = 1000, retries_left = 20)
+ begin
+ yield
+ rescue Plaid::ApiError => e
+ if retries_left > 0
+ sleep(ms / 1000.0)
+ poll_with_retries(ms, retries_left - 1) { yield }
+ else
+ raise 'Ran out of retries while polling'
+ end
+ end
+end
+
+def format_error(err)
+ body = JSON.parse(err.response_body)
+ {
+ error: {
+ status_code: err.code,
+ error_code: body['error_code'],
+ error_message: body['error_message'],
+ error_type: body['error_type']
+ }
+ }
+end
+
+def pretty_print_response(response)
+ puts JSON.pretty_generate(response)
end
diff --git a/ruby/public/style.css b/ruby/public/style.css
deleted file mode 100644
index caeea4798..000000000
--- a/ruby/public/style.css
+++ /dev/null
@@ -1,51 +0,0 @@
-html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, font, img, kbd, q, s, samp,
-small, strike, sub, sup, tt, var, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td {
-margin: 0; padding: 0; border: 0; outline: 0; font-weight: inherit; font-style: inherit; font-size: 100%; font-family: inherit; vertical-align: baseline; }
-:focus { outline: 0; }
-body { line-height: 1; }
-
-html {
- color: #444;
- font: normal 62.5%/1 helvetica, arial, sans-serif;
- padding: 0px;
- margin: 0;
- text-align: center;
- background: #f9f9f9;
-}
-
-body {
- padding: 0px;
- margin: 0px;
- text-align: center;
-}
-
-a, a:visited { color: #3a98c9; text-decoration: none; }
-a:hover { text-decoration: underline; }
-
-#banner, #container, .box { min-width: 280px; max-width: 800px; margin: 20px auto 0; padding: 20px; background: #fff; border: 1px solid #c9c9c9; border-radius: 2px; text-align: left; }
-#container p { font-size: 14px; line-height: 17px; margin-bottom: 20px; }
-button {
- background-color: #1a476a;
- background-image: -webkit-linear-gradient(top, #29618e, #164a74);
- background-image: linear-gradient(to bottom, #29618e, #164a74);
- border-color: #1a476a;
- border-style: solid;
- border-width: 1px;
- box-shadow: inset 0 1px 2px rgba(255,255,255,0.1),0 1px 2px rgba(19,49,69,0.2);
- color: #fff;
- text-shadow: 0 2px 4px rgba(0,0,0,0.1);
- padding: 10px 30px;
- font-size: 18px;
- border-radius: 4px;
-}
-button:hover { color: #f1f1f1; cursor: pointer; }
-
-#app { display: none; }
-#app textarea { display: none; height: 100px; width: 260px; padding: 10px; font-size: 14px; }
-.box { margin: 20px auto 0; }
-.inner { background: #f3f3f3; font-size: 14px; line-height: 17px; padding: 20px; border-radius: 2px; margin-top: 20px; }
-#banner { border-top: 0px; margin-top: 0px; border-radius: 0 0 2px 2px; }
-#banner h1 { color: #1a476a; font-size: 18px; font-weight: bold; }
-#banner p { font-size: 14px; line-height: 17px; margin-top: 5px; }
-#steps { display: none; }
-.green { background: #3ab683; color: #fff; }
diff --git a/ruby/start.sh b/ruby/start.sh
new file mode 100755
index 000000000..739cd5c1c
--- /dev/null
+++ b/ruby/start.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+bundle exec ruby app.rb
\ No newline at end of file
diff --git a/ruby/views/index.erb b/ruby/views/index.erb
deleted file mode 100644
index 89e386af2..000000000
--- a/ruby/views/index.erb
+++ /dev/null
@@ -1,152 +0,0 @@
-
-
-
-
- Plaid Walkthrough Example
-
-
-
-
-
-
Plaid Example Walkthrough
-
- This is an example application that walks through integrating Plaid Link using the API to retrieve Auth and Transaction data.
-
-
- Great - you just created an Item! The server was successfully able to exchange the public_token for an access_token.
- Below are a few options - you can get account data, retrieve information about the Item itself, or pull transaction data.
-
-
-
-
-
- Click the button below to open a list of Institutions - after you select one,
- you'll be guided through an authentication process. The public_token will be passed
- back to the example server, which will then exchange it for an access token and log it
- to your console.
-