How to Integrate Replit with Yodlee

1// check-yodlee-secrets.js
2const hasJWT = !!(process.env.YODLEE_CLIENT_ID && process.env.YODLEE_CLIENT_SECRET);
3const hasSession = !!(process.env.YODLEE_COBRAND_LOGIN && process.env.YODLEE_COBRAND_PASSWORD);
4const hasUrl = !!process.env.YODLEE_BASE_URL;
5
6if (!hasUrl) throw new Error('YODLEE_BASE_URL missing. Set in Replit Secrets (lock icon 🔒).');
7if (!hasJWT && !hasSession) throw new Error('Set YODLEE_CLIENT_ID + YODLEE_CLIENT_SECRET or YODLEE_COBRAND_LOGIN + YODLEE_COBRAND_PASSWORD.');
8
9console.log('Yodlee secrets verified.');
10console.log('Auth type:', hasJWT ? 'JWT API 1.1' : 'Session API 1.0');
11console.log('API base URL:', process.env.YODLEE_BASE_URL);

1// yodlee.js — Yodlee API 1.1 (JWT) integration for Node.js on Replit
2const axios = require('axios');
3const jwt = require('jsonwebtoken');
4const express = require('express');
5
6const app = express();
7app.use(express.json());
8
9const BASE_URL = process.env.YODLEE_BASE_URL;
10const CLIENT_ID = process.env.YODLEE_CLIENT_ID;
11const CLIENT_SECRET = process.env.YODLEE_CLIENT_SECRET;
12
13// Token cache to avoid re-authenticating on every request
14let cobrandToken = null;
15let tokenExpiry = 0;
16
17// Generate JWT and exchange for Yodlee access token
18async function getCobrandToken() {
19  if (cobrandToken && Date.now() < tokenExpiry) return cobrandToken;
20  
21  const now = Math.floor(Date.now() / 1000);
22  const jwtToken = jwt.sign(
23    { iss: CLIENT_ID, iat: now, exp: now + 1800 },
24    CLIENT_SECRET,
25    { algorithm: 'HS512' }
26  );
27  
28  const response = await axios.post(`${BASE_URL}/auth/token`, null, {
29    headers: {
30      'Api-Version': '1.1',
31      'Authorization': `Bearer ${jwtToken}`,
32      'loginName': 'cobrand'  // For cobrand-level auth
33    }
34  });
35  
36  cobrandToken = response.data.token?.accessToken;
37  tokenExpiry = Date.now() + (1700 * 1000);  // Refresh before expiry
38  return cobrandToken;
39}
40
41// Get token for a specific user
42async function getUserToken(loginName) {
43  const cobToken = await getCobrandToken();
44  
45  const now = Math.floor(Date.now() / 1000);
46  const userJwt = jwt.sign(
47    { iss: CLIENT_ID, sub: loginName, iat: now, exp: now + 1800 },
48    CLIENT_SECRET,
49    { algorithm: 'HS512' }
50  );
51  
52  const response = await axios.post(`${BASE_URL}/auth/token`, null, {
53    headers: {
54      'Api-Version': '1.1',
55      'Authorization': `Bearer ${userJwt}`,
56      'loginName': loginName
57    }
58  });
59  
60  return response.data.token?.accessToken;
61}
62
63// Get all linked accounts for a user
64app.get('/api/accounts/:loginName', async (req, res) => {
65  try {
66    const userToken = await getUserToken(req.params.loginName);
67    const response = await axios.get(`${BASE_URL}/accounts`, {
68      headers: { 'Api-Version': '1.1', 'Authorization': `Bearer ${userToken}` }
69    });
70    res.json({ accounts: response.data.account || [] });
71  } catch (err) {
72    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
73  }
74});
75
76// Get transaction history for a user
77app.get('/api/transactions/:loginName', async (req, res) => {
78  const { fromDate, toDate, accountId } = req.query;
79  try {
80    const userToken = await getUserToken(req.params.loginName);
81    const params = { 'transaction.fromDate': fromDate, 'transaction.toDate': toDate };
82    if (accountId) params.accountId = accountId;
83    
84    const response = await axios.get(`${BASE_URL}/transactions`, {
85      headers: { 'Api-Version': '1.1', 'Authorization': `Bearer ${userToken}` },
86      params
87    });
88    res.json({
89      transactions: response.data.transaction || [],
90      totalCount: response.data.transaction?.length || 0
91    });
92  } catch (err) {
93    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
94  }
95});
96
97// Generate FastLink token for bank-linking UI
98app.post('/api/fastlink-token/:loginName', async (req, res) => {
99  try {
100    const userToken = await getUserToken(req.params.loginName);
101    const response = await axios.post(`${BASE_URL}/user/accessTokens`, {
102      appIds: ['10003600']  // FastLink app ID — check your Yodlee portal for the correct value
103    }, {
104      headers: { 'Api-Version': '1.1', 'Authorization': `Bearer ${userToken}` }
105    });
106    res.json({ fastLinkToken: response.data.user?.accessTokens?.[0]?.value });
107  } catch (err) {
108    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
109  }
110});
111
112app.listen(3000, '0.0.0.0', () => console.log('Yodlee server running on port 3000'));

1# yodlee_api.py — Yodlee API 1.1 (JWT) for Python on Replit
2import os
3import time
4import jwt
5import requests
6from flask import Flask, request, jsonify
7
8BASE_URL = os.environ['YODLEE_BASE_URL']
9CLIENT_ID = os.environ['YODLEE_CLIENT_ID']
10CLIENT_SECRET = os.environ['YODLEE_CLIENT_SECRET']
11
12app = Flask(__name__)
13
14# Token cache
15_cobrand_token = None
16_token_expiry = 0
17
18def generate_jwt(login_name='cobrand'):
19    """Generate a Yodlee JWT for authentication."""
20    now = int(time.time())
21    payload = {'iss': CLIENT_ID, 'iat': now, 'exp': now + 1800}
22    if login_name != 'cobrand':
23        payload['sub'] = login_name
24    return jwt.encode(payload, CLIENT_SECRET, algorithm='HS512')
25
26def get_cobrand_token():
27    global _cobrand_token, _token_expiry
28    if _cobrand_token and time.time() < _token_expiry:
29        return _cobrand_token
30    
31    jwt_token = generate_jwt('cobrand')
32    response = requests.post(f'{BASE_URL}/auth/token', headers={
33        'Api-Version': '1.1',
34        'Authorization': f'Bearer {jwt_token}',
35        'loginName': 'cobrand'
36    })
37    response.raise_for_status()
38    _cobrand_token = response.json()['token']['accessToken']
39    _token_expiry = time.time() + 1700
40    return _cobrand_token
41
42def get_user_token(login_name: str):
43    """Get access token for a specific user."""
44    jwt_token = generate_jwt(login_name)
45    response = requests.post(f'{BASE_URL}/auth/token', headers={
46        'Api-Version': '1.1',
47        'Authorization': f'Bearer {jwt_token}',
48        'loginName': login_name
49    })
50    response.raise_for_status()
51    return response.json()['token']['accessToken']
52
53@app.route('/api/accounts/<login_name>')
54def get_accounts(login_name):
55    try:
56        user_token = get_user_token(login_name)
57        response = requests.get(f'{BASE_URL}/accounts', headers={
58            'Api-Version': '1.1',
59            'Authorization': f'Bearer {user_token}'
60        })
61        response.raise_for_status()
62        return jsonify({'accounts': response.json().get('account', [])})
63    except requests.HTTPError as e:
64        return jsonify({'error': e.response.json()}), e.response.status_code
65
66@app.route('/api/transactions/<login_name>')
67def get_transactions(login_name):
68    from_date = request.args.get('fromDate')
69    to_date = request.args.get('toDate')
70    try:
71        user_token = get_user_token(login_name)
72        params = {}
73        if from_date:
74            params['transaction.fromDate'] = from_date
75        if to_date:
76            params['transaction.toDate'] = to_date
77        response = requests.get(f'{BASE_URL}/transactions', headers={
78            'Api-Version': '1.1',
79            'Authorization': f'Bearer {user_token}'
80        }, params=params)
81        response.raise_for_status()
82        transactions = response.json().get('transaction', [])
83        return jsonify({'transactions': transactions, 'count': len(transactions)})
84    except requests.HTTPError as e:
85        return jsonify({'error': e.response.text}), e.response.status_code
86
87if __name__ == '__main__':
88    app.run(host='0.0.0.0', port=3000)