How to Integrate Retool with Yodlee

Register at developer.yodlee.com and create an application to receive your Yodlee API credentials: a Client ID and Client Secret. For development, Yodlee provides Sandbox access immediately after registration. Production access requires a business agreement and approval process. Once you have credentials, understand Yodlee's two-tier authentication before building anything in Retool — this architecture is fundamentally different from standard single-token APIs and must be handled correctly. Tier 1: Admin Token. Obtained by POSTing to the token endpoint with your Client ID and Client Secret using the client credentials OAuth grant. The admin token is valid for 30 minutes and is used ONLY for user management operations (creating users, getting user lists). It cannot access financial data. Tier 2: User JWT. To access any financial data (accounts, transactions, holdings) for a specific user, you must generate a user-level JWT. This requires a POST to the same token endpoint but including the Yodlee username for the specific user in the request body alongside the admin client credentials. The user JWT is also short-lived (typically 30 minutes). In Retool Settings → Configuration Variables, add: YODLEE_CLIENT_ID, YODLEE_CLIENT_SECRET, and YODLEE_API_BASE_URL (set to https://sandbox.api.yodlee.com/ysl for sandbox or https://production.api.yodlee.com/ysl for production). Mark Client Secret as secret. Token management will be handled by JavaScript queries in the app rather than by the resource configuration directly.

1// Yodlee Admin Token Request — POST body (application/x-www-form-urlencoded)
2// POST to {base_url}/auth/token
3clientId={{ retoolContext.configVars.YODLEE_CLIENT_ID }}
4secret={{ retoolContext.configVars.YODLEE_CLIENT_SECRET }}

In Retool, navigate to the Resources tab and Add Resource. Select REST API. Name it 'Yodlee API'. In the Base URL field, enter {{ retoolContext.configVars.YODLEE_API_BASE_URL }}. Because Yodlee's tokens are dynamic and short-lived (not static configuration values), use 'No Auth' as the authentication type in the resource — you will pass the token in individual query headers using dynamic references. In the Headers section, add a default header: Api-Version = 1.1 (required for all Yodlee requests). Click Save Changes. Now create token management queries in your Retool app. Open or create an app, then in the Code panel create a JavaScript query named 'getAdminToken'. This query POSTs to the Yodlee token endpoint and stores the result. Set the query type to JavaScript and write code that uses fetch() with Retool's built-in utilities to call the token endpoint. Alternatively, create a REST query named 'fetchAdminToken': select the Yodlee API resource, set Method to POST, Path to /auth/token, Body Type to x-www-form-urlencoded, and Body to clientId={{ retoolContext.configVars.YODLEE_CLIENT_ID }}&secret={{ retoolContext.configVars.YODLEE_CLIENT_SECRET }}. Create a second query named 'fetchUserToken' with the same configuration but add the loginName parameter: clientId={{ retoolContext.configVars.YODLEE_CLIENT_ID }}&secret={{ retoolContext.configVars.YODLEE_CLIENT_SECRET }}&loginName={{ userIdInput.value }}. The user token response contains an 'access_token' string — reference this token in subsequent financial data queries as a custom Authorization header: { Authorization: 'Bearer ' + fetchUserToken.data.token.accessToken }.

1// Yodlee User Token Request — form-encoded POST
2// Use loginName to get user-specific JWT
3// POST {base_url}/auth/token
4clientId={{ retoolContext.configVars.YODLEE_CLIENT_ID }}&secret={{ retoolContext.configVars.YODLEE_CLIENT_SECRET }}&loginName={{ userIdInput.value }}

With token acquisition working, build the financial data queries. Create a new query named 'getAccounts', select the Yodlee API resource, set Method to GET, and Path to /accounts. In the Headers section of this specific query, add a custom header: Authorization = Bearer {{ fetchUserToken.data.token.accessToken }}. This passes the user-level JWT for the selected user — if the user token hasn't been fetched yet, set a run dependency: in the query's Advanced settings, under 'Run after query', select fetchUserToken. This ensures the user token is always fresh before the accounts query runs. Add a URL parameter: key 'container', value 'bank,creditCard,investment,insurance,loan' to retrieve all account types. The accounts response contains an 'account' array with objects including: id, accountName, accountNumber (masked), accountType, balance.amount, balance.currency, providerName, refreshInfo.lastRefreshed, and refreshInfo.statusCode. Create a transformer for the accounts query that extracts and normalizes this data, converting balance amounts to a consistent currency display format and calculating data freshness in hours. Create a second query 'getTransactions' with Method GET, Path /transactions, the same Authorization header dependency, and URL parameters: 'fromDate' = {{ dateRange.startDate }}, 'toDate' = {{ dateRange.endDate }}, 'accountId' = {{ accountsTable.selectedRow?.id || '' }}, 'top' = 100.

1// Transformer: normalize Yodlee accounts response
2const accounts = data.account || [];
3return accounts.map(acct => {
4  const lastRefreshed = acct.refreshInfo?.lastRefreshed
5    ? new Date(acct.refreshInfo.lastRefreshed)
6    : null;
7  const hoursOld = lastRefreshed
8    ? Math.floor((Date.now() - lastRefreshed.getTime()) / (1000 * 60 * 60))
9    : null;
10  const statusCode = acct.refreshInfo?.statusCode;
11  const isHealthy = statusCode === 0 || statusCode === 801; // 0=ok, 801=ok_partial
12
13  return {
14    id: acct.id,
15    account_name: acct.accountName,
16    account_number: acct.accountNumber || 'N/A',
17    account_type: acct.accountType,
18    provider: acct.providerName,
19    balance: acct.balance
20      ? `${acct.balance.currency} ${acct.balance.amount.toFixed(2)}`
21      : 'N/A',
22    balance_amount: acct.balance?.amount || 0,
23    last_refreshed: lastRefreshed ? lastRefreshed.toLocaleString() : 'Never',
24    data_age_hours: hoursOld,
25    connection_status: isHealthy ? 'Healthy' : `Error (${statusCode})`
26  };
27});

With queries configured, build the dashboard. Add a Text Input component named 'userIdInput' at the top with label 'Yodlee User Login Name'. Add a 'Load Data' button that triggers fetchUserToken on click (which cascades to getAccounts via the query dependency). Below the user input, add a Stats row: total account count, total net assets (sum of positive balances), total liabilities (credit card and loan balances), and accounts with connection errors (count where connection_status is not 'Healthy'). Drag a Table component, bind it to {{ getAccounts.data }}, and configure columns: provider, account_name, account_type, balance, last_refreshed, data_age_hours (with conditional formatting: red text if > 24 hours), and connection_status (green for Healthy, red for Error). When a row is selected, trigger the getTransactions query via event handler. Add a second Table component below for transactions, bound to {{ getTransactions.data }}. Create a transformer for transactions that extracts: date, merchant name (from transaction.merchant.name or transaction.description), amount (positive for credits, negative for debits), category (from transaction.highLevelCategoryId or transaction.categoryId lookup), and base type (CREDIT or DEBIT). Add a Date Range Picker that controls the transaction query parameters. For fintech applications managing large user populations across multiple Yodlee accounts, RapidDev can help architect a scalable Retool solution with token caching and multi-user management.

1// Transformer: normalize Yodlee transactions
2const transactions = data.transaction || [];
3return transactions.map(t => ({
4  id: t.id,
5  date: t.date,
6  description: t.merchant?.name || t.description || 'N/A',
7  amount: t.baseType === 'DEBIT'
8    ? -Math.abs(t.amount.amount)
9    : Math.abs(t.amount.amount),
10  currency: t.amount.currency,
11  category: t.categoryType || t.highLevelCategoryId || 'Uncategorized',
12  base_type: t.baseType,
13  account_id: t.accountId,
14  status: t.status
15}));

Yodlee tokens expire after 30 minutes, which means dashboards left open will eventually fail with 401 errors as tokens expire mid-session. Build an automatic refresh mechanism to keep the dashboard operational. Option 1 — In-app polling: Create a Timer component in Retool (drag from the component panel) and set it to run every 25 minutes. Connect its trigger event to run fetchUserToken (which automatically re-runs getAccounts and getTransactions via dependencies). This keeps the session active for as long as the app is open. Option 2 — Retool Workflow: For more robust token management in production, create a Retool Workflow. Set a schedule trigger at 25-minute intervals. Add a Resource Query block that POSTs to the Yodlee token endpoint using your admin credentials and stores the token in a Retool Database row keyed by user ID. In your Retool app, read the current token from Retool Database rather than calling the token endpoint directly. This decouples token management from the dashboard UI. Add error handling to both approaches: if a token fetch fails (network error or invalid credentials), display an error notification in the dashboard and disable query triggers to prevent cascading failures. Reference the access token in financial data query headers dynamically: in each query's Headers section, add Authorization = Bearer {{ fetchUserToken.data?.token?.accessToken || '' }}. The optional chaining (?.) prevents errors if the token query hasn't run yet.

1// JavaScript: check token validity before running financial queries
2const tokenData = fetchUserToken.data?.token;
3if (!tokenData || !tokenData.accessToken) {
4  utils.showNotification({
5    title: 'Authentication Required',
6    description: 'Yodlee session expired. Re-enter user ID and click Load Data.',
7    type: 'warning'
8  });
9  return;
10}
11// Token valid — trigger dependent queries
12await getAccounts.trigger();
13await getTransactions.trigger();