# How to Integrate Retool with Mint (discontinued) / Plaid Alternative

- Tool: Retool
- Difficulty: Advanced
- Time required: 40 minutes
- Last updated: April 2026

## TL;DR

Mint was discontinued in January 2024 and its users were migrated to Credit Karma. There is no active Mint API to connect to Retool. For personal finance dashboards, connect Retool to Plaid's financial data aggregation API instead — Plaid provides bank account balances, transactions, and investment data through a well-documented REST API, giving you the personal finance data infrastructure that Mint was built on.

## Mint Is Discontinued: Building a Personal Finance Dashboard with Plaid in Retool

Intuit announced the shutdown of Mint in November 2023, with the service going offline in January 2024. Users were directed to migrate to Credit Karma, another Intuit product focused on credit scores and financial monitoring. However, Credit Karma does not offer a public API, making it unsuitable as a data source for Retool dashboards.

For teams or individuals who want to replicate Mint's core functionality — aggregated bank account balances, transaction categorization, and spending analytics — in a custom Retool dashboard, Plaid is the recommended alternative. Plaid is the financial data infrastructure API that powered Mint itself, as well as thousands of other fintech applications. Plaid provides access to bank account balances, transaction history, investment accounts, and income verification through a secure, well-documented REST API with SDKs for all major languages.

Building a personal finance dashboard in Retool with Plaid enables custom spending analysis, budget tracking against internal targets, and combination with other business data (like QuickBooks for business expenses). The key architectural consideration is that Plaid requires a user authorization flow (Plaid Link) to connect bank accounts — this flow is typically handled in a separate web application, with the resulting access_token stored securely and used by Retool queries to fetch financial data. The Plaid sandbox environment provides synthetic bank data for testing, making it safe to develop the dashboard before connecting real accounts.

## Before you start

- A Retool account (Cloud or self-hosted) with permission to create Resources
- A Plaid developer account at dashboard.plaid.com — the free Sandbox environment requires no payment information and provides realistic synthetic financial data for development
- Plaid API credentials: client_id and secret (found in the Plaid Dashboard under Keys) — note that Plaid has separate keys for Sandbox, Development, and Production environments
- An understanding of Plaid's two-phase architecture: the Plaid Link frontend flow (handled outside Retool) that generates an access_token, and the Plaid API backend calls (handled in Retool) that use the access_token to fetch data
- For real account data: a Plaid Development or Production account, which requires applying for access and agreeing to Plaid's usage policies — sandbox access is available immediately after signup

## Step-by-step guide

### 1. Understand the Mint discontinuation and evaluate Plaid as the replacement

Before building, it is important to understand the Mint situation and plan the replacement architecture. Mint officially shut down in January 2024. Intuit directed users to Credit Karma, but Credit Karma provides no public API for programmatic data access. Former Mint users who want to continue accessing their financial data in Retool have these options:

1. Plaid (recommended): The financial data infrastructure API used by thousands of apps including Venmo, Robinhood, and Acorns. Plaid aggregates bank data, transactions, and investment accounts. This is the most comprehensive replacement.

2. Yodlee: Another financial aggregation platform with similar capabilities to Plaid, often preferred for enterprise financial applications. More complex authentication but broader institutional coverage.

3. Manual import: Export Mint transaction history from the Mint website before shutdown (if you did so before January 2024) or import bank CSV exports directly into Retool via a database upload.

For this guide, we focus on Plaid as the primary replacement. Sign up at dashboard.plaid.com — the Sandbox environment is immediately available with no approval required. Production API access requires applying and explaining your use case.

In Plaid's dashboard, navigate to Keys to find your client_id and sandbox secret. These are the credentials you will use in Retool. Keep the Production secret separate and store it only after you have completed sandbox development and testing.

**Expected result:** You have a Plaid developer account with Sandbox access and your client_id and sandbox secret from the Plaid Dashboard. You have decided on Plaid as your Mint replacement and understand that the integration requires a Plaid Link authorization flow for connecting bank accounts.

### 2. Create the Plaid REST API Resource in Retool

Plaid's API uses a JSON body-based authentication model — credentials are sent in the request body rather than headers. However, for the Retool resource configuration, you can use custom default headers or configure the client_id and secret as constants referenced in each query body.

Navigate to the Resources tab in Retool and click Add Resource. Select REST API from the resource type list. Configure the resource:

- Name: 'Plaid API'
- Base URL: https://sandbox.plaid.com (for sandbox testing)
  - For Development: https://development.plaid.com
  - For Production: https://production.plaid.com

For authentication, Plaid does not use standard Bearer or Basic auth — credentials go in the POST request body. Select No Authentication from the Auth dropdown.

Add default headers:
- Key: Content-Type, Value: application/json
- Key: Plaid-Version, Value: 2020-09-14

Click Save Changes.

Store your Plaid credentials as Retool Configuration Variables (Settings → Configuration Variables):
- PLAID_CLIENT_ID: your Plaid client ID
- PLAID_SECRET: your sandbox (or production) secret key

Mark PLAID_SECRET as secret so it is never exposed to the Retool frontend. You will reference these configuration variables in the request body of each Plaid query using {{ retoolContext.configVars.PLAID_CLIENT_ID }}.

Verify the resource by creating a test query:
- Method: POST
- Path: /institutions/get
- Body: { "client_id": "{{ retoolContext.configVars.PLAID_CLIENT_ID }}", "secret": "{{ retoolContext.configVars.PLAID_SECRET }}", "count": 5, "offset": 0, "country_codes": ["US"] }

**Expected result:** The Plaid REST API Resource appears in the Resources list. A test POST to /institutions/get returns a list of financial institutions from the Plaid sandbox, confirming the resource configuration and credentials are correct.

### 3. Obtain a Plaid access_token using the Link flow

Plaid uses a two-phase authentication model for connecting to bank accounts. The first phase — Plaid Link — is a frontend authorization flow where users connect their bank accounts through Plaid's hosted UI. The second phase uses the resulting access_token in server-side API calls to fetch the connected account's data.

For a Retool-only workflow (without a separate web application), there are two approaches:

Approach A — Sandbox testing with a test access_token: Plaid provides pre-generated sandbox access tokens for testing without going through the Link flow. Use the /sandbox/public_token/create endpoint to generate a test public_token, then exchange it for an access_token using /item/public_token/exchange. Store the resulting access_token as a Retool Configuration Variable (PLAID_ACCESS_TOKEN). This approach works for development and internal tools where you control which accounts are connected.

Approach B — Link flow via a separate web page: For connecting real user bank accounts, implement Plaid Link in a separate Next.js or HTML page. When a user completes the Link flow, exchange the public_token on your server and store the access_token in your database. Your Retool app then queries that database for the access_token to use in Plaid API calls.

For internal team finance dashboards (the most common Retool use case), Approach A is sufficient: create a sandbox access_token for testing, and for production, exchange the public_token from a simple standalone Link implementation and store the result in a database or Retool Configuration Variable.

```
// POST to /sandbox/public_token/create to generate test public_token
// Use this body in a Retool query for sandbox testing only
{
  "client_id": "{{ retoolContext.configVars.PLAID_CLIENT_ID }}",
  "secret": "{{ retoolContext.configVars.PLAID_SECRET }}",
  "institution_id": "ins_109508",
  "initial_products": ["transactions", "auth"],
  "options": { "webhook": "" }
}

// Then POST to /item/public_token/exchange with:
{
  "client_id": "{{ retoolContext.configVars.PLAID_CLIENT_ID }}",
  "secret": "{{ retoolContext.configVars.PLAID_SECRET }}",
  "public_token": "{{ sandboxTokenQuery.data.public_token }}"
}
// Store the returned access_token in PLAID_ACCESS_TOKEN config variable
```

**Expected result:** You have a Plaid access_token stored as a Retool Configuration Variable. The token is valid for the sandbox institution and can be used to fetch account balances and transactions in subsequent steps.

### 4. Query account balances and build a net worth overview

With an access_token available, query Plaid's /accounts/balance/get endpoint to retrieve real-time account balances for all connected bank accounts. This endpoint returns current and available balances for checking, savings, credit card, and investment accounts.

Create a new query using the Plaid API resource:
- Method: POST
- Path: /accounts/balance/get
- Body type: Raw JSON
- Body: a JSON object with client_id, secret, and access_token fields

The response returns an accounts array where each account object has: account_id, name, official_name, type (depository, credit, investment), subtype (checking, savings, etc.), balances (current, available, limit), and mask (last 4 digits of account number).

Write a JavaScript transformer that separates accounts into asset accounts (depository, investment) and liability accounts (credit, loan). Calculate total assets, total liabilities, and net worth. Format all currency values with dollar signs and two decimal places.

Bind three Stat components to the transformer's totals: Total Assets, Total Liabilities, and Net Worth. Below the stats, display a Table of all accounts with columns for account name, type, current balance, and available balance. Positive balances display in green, credit balances (negative net worth impact) display in red.

```
// POST /accounts/balance/get body
{
  "client_id": "{{ retoolContext.configVars.PLAID_CLIENT_ID }}",
  "secret": "{{ retoolContext.configVars.PLAID_SECRET }}",
  "access_token": "{{ retoolContext.configVars.PLAID_ACCESS_TOKEN }}"
}

// ---
// JavaScript transformer for account balance response
const accounts = data?.accounts || [];

const formatted = accounts.map(account => ({
  id: account.account_id,
  name: account.name || account.official_name || 'Unknown Account',
  type: account.type,
  subtype: account.subtype,
  mask: account.mask ? '***' + account.mask : '',
  current_balance: account.balances?.current ?? 0,
  available_balance: account.balances?.available ?? null,
  currency: account.balances?.iso_currency_code || 'USD',
  current_display: `$${(account.balances?.current ?? 0).toFixed(2)}`,
  is_liability: ['credit', 'loan'].includes(account.type)
}));

const totalAssets = formatted
  .filter(a => !a.is_liability)
  .reduce((sum, a) => sum + a.current_balance, 0);

const totalLiabilities = formatted
  .filter(a => a.is_liability)
  .reduce((sum, a) => sum + a.current_balance, 0);

return {
  accounts: formatted,
  total_assets: totalAssets,
  total_liabilities: totalLiabilities,
  net_worth: totalAssets - totalLiabilities,
  total_assets_display: `$${totalAssets.toFixed(2)}`,
  total_liabilities_display: `$${totalLiabilities.toFixed(2)}`,
  net_worth_display: `$${(totalAssets - totalLiabilities).toFixed(2)}`
};
```

**Expected result:** The dashboard shows Stat components for Total Assets, Total Liabilities, and Net Worth calculated from Plaid account balances. A Table below lists all connected accounts with their balances. The data reflects the sandbox test account balances.

### 5. Query transactions and build a spending analytics view

Plaid's /transactions/get endpoint returns categorized transaction history for connected accounts. This is the core data source for replicating Mint's spending analysis features in Retool.

Create a new query using the Plaid API resource:
- Method: POST
- Path: /transactions/get
- Body: JSON object with client_id, secret, access_token, start_date, end_date, and options

The response returns a transactions array with fields: transaction_id, account_id, date, name (merchant name), amount (positive = debit, negative = credit/refund in Plaid's convention), category (array of category strings), and location data. Note that Plaid amounts use a positive-for-debit convention for transactions — $50 spent is returned as 50.0.

Write a transformer that converts the raw transaction array into a display-ready format, aggregates spending by category, and filters out transfers and credits. Use the first category element as the primary category label.

Build two views from this data: a Table showing individual transactions sorted by date (most recent first) with merchant name, date, category, and formatted amount — and a Bar Chart or Pie Chart showing spending aggregated by top category for the selected month. Connect a date range picker to the start_date and end_date parameters to let users filter by period.

```
// POST /transactions/get body
{
  "client_id": "{{ retoolContext.configVars.PLAID_CLIENT_ID }}",
  "secret": "{{ retoolContext.configVars.PLAID_SECRET }}",
  "access_token": "{{ retoolContext.configVars.PLAID_ACCESS_TOKEN }}",
  "start_date": "{{ dateRangePicker.startDate || new Date(new Date().getFullYear(), new Date().getMonth(), 1).toISOString().split('T')[0] }}",
  "end_date": "{{ dateRangePicker.endDate || new Date().toISOString().split('T')[0] }}",
  "options": { "count": 100, "offset": 0 }
}

// ---
// JavaScript transformer for Plaid transactions
const transactions = data?.transactions || [];

// Format individual transactions
const formatted = transactions
  .filter(t => !['Transfer', 'Payment'].includes(t.category?.[0] || ''))
  .map(t => ({
    id: t.transaction_id,
    date: t.date,
    merchant: t.merchant_name || t.name || 'Unknown',
    category: t.category?.[0] || 'Uncategorized',
    subcategory: t.category?.[1] || '',
    amount: t.amount,
    amount_display: `$${Math.abs(t.amount).toFixed(2)}`,
    is_credit: t.amount < 0
  }));

// Aggregate by category for chart
const byCategory = {};
formatted.filter(t => !t.is_credit).forEach(t => {
  byCategory[t.category] = (byCategory[t.category] || 0) + t.amount;
});

const categoryChart = Object.entries(byCategory)
  .map(([category, total]) => ({ category, total: parseFloat(total.toFixed(2)) }))
  .sort((a, b) => b.total - a.total)
  .slice(0, 10);

return { transactions: formatted, categoryChart };
```

**Expected result:** A spending analytics view shows a Pie or Bar chart of spending by category for the selected date range and a Table of individual transactions. The date range picker updates both views. Transaction data matches the Plaid sandbox account's synthetic transaction history.

## Best practices

- Always develop and test Plaid integration against the sandbox environment before applying for production access — the sandbox is identical in API structure to production but uses synthetic data.
- Store Plaid access_tokens in an encrypted database rather than as Retool Configuration Variables for multi-user applications — Configuration Variables are shared across all Retool users, making them inappropriate for user-specific financial tokens.
- Mark the PLAID_SECRET Configuration Variable as secret in Retool to prevent it from being exposed to the frontend — Plaid secrets are equivalent to database passwords and must be kept server-side.
- Use Plaid's /transactions/sync endpoint instead of /transactions/get for applications that need to keep transaction data up to date incrementally — the sync endpoint is more efficient for ongoing updates and is Plaid's recommended approach for production use.
- Implement error handling in all Plaid query transformers — check for error codes in the response before accessing data, as Plaid returns error objects with error_code and error_message when requests fail.
- Cache Plaid balance data for a few minutes using Retool's query caching feature — real-time balance queries hit the financial institution directly and are slower than cached responses.
- For compliance and security, never log or store raw Plaid access_tokens in application logs, browser console outputs, or unencrypted storage — treat them with the same security controls as database passwords.

## Use cases

### Build a personal finance overview dashboard replacing Mint

Create a Retool dashboard that uses Plaid to display all connected bank account balances, recent transactions, and a monthly spending breakdown by category — replicating the core Mint experience with full customization. Account balances display in real-time via Plaid's balance endpoint, and transactions from the last 30 days feed category-aggregated spending charts. Personal finance managers and financially-minded individuals use this as their daily money overview.

Prompt example:

```
Build a personal finance dashboard that queries Plaid for all account balances and recent transactions. Show a Stat row with total assets (sum of all account balances), total liabilities, and net worth. Display a Table of recent transactions with date, merchant name, category, and amount. Add a pie chart showing spending by category for the current month. All data should refresh on a button click.
```

### Create a budget tracking panel with spending vs targets

Build a Retool budget management panel that fetches transaction data from Plaid, aggregates spending by Plaid's category classification, and compares actual spending against budget targets stored in a Retool Database or PostgreSQL table. When spending exceeds a budget category threshold, the panel highlights it in red. Finance-conscious users or small business owners tracking personal expenses use this for monthly financial reviews.

Prompt example:

```
Create a budget tracker that queries Plaid transactions for the current month and aggregates spending by category. Join with a budget_targets table from the internal database. Display a Table with category, budget target, actual spent, remaining budget, and a percentage bar. Highlight rows in red where spending exceeds the budget. Add Stat components for total budget, total spent, and overall budget remaining.
```

### Build a multi-account financial aggregation panel for a fintech application

For teams building fintech products, connect Retool to Plaid to create an internal operations dashboard that views connected user accounts' financial summaries. Monitor which accounts are connected, their balance totals, last transaction sync time, and error status (for accounts that have lost connection). Operations teams use this to troubleshoot Plaid connection issues and monitor the health of their financial data pipeline.

Prompt example:

```
Build a fintech ops dashboard that queries your Plaid application's connected items and their account statuses. Show a Table of all Plaid Items with the institution name, connection status, number of accounts, last successful sync, and any error codes. Add a detail panel that shows account-level balance information when an Item is selected. Include a 'Reconnect' action button for Items with connection errors.
```

## Troubleshooting

### Plaid API returns INVALID_API_KEYS error on all requests

Cause: The client_id or secret being passed in the request body does not match the credentials for the selected environment (sandbox, development, or production). Plaid uses separate credential sets for each environment.

Solution: Verify that the PLAID_CLIENT_ID and PLAID_SECRET Configuration Variables in Retool match the environment's credentials from the Plaid Dashboard Keys section. If testing in sandbox, ensure you are using the sandbox secret (not the development or production secret) and the resource base URL is https://sandbox.plaid.com. Sandbox, development, and production credentials are different and cannot be interchanged.

### Transactions query returns PRODUCT_NOT_READY error

Cause: When a new Plaid Item (bank account connection) is first created, Plaid performs an initial transaction fetch that can take a few minutes. Querying /transactions/get before this initial sync completes returns PRODUCT_NOT_READY.

Solution: Wait 1-2 minutes after creating the access_token before querying transactions, then retry. In production applications, implement Plaid webhooks to receive a notification when the initial transaction sync is complete (INITIAL_UPDATE and HISTORICAL_UPDATE events). For sandbox testing, the initial sync is typically fast but may still require a brief wait after token creation.

### Account balances or transaction amounts show as null or undefined in the Retool transformer

Cause: Plaid's balance object uses nested fields (balances.current, balances.available) that may be null for certain account types — investment accounts may not have an available balance, and some institutions don't provide real-time balance data for certain account types.

Solution: Add null checks throughout the transformer using optional chaining (?.) and nullish coalescing (??) with 0 as the fallback for balance calculations. Never assume balance fields will be populated — different account types and institutions provide different subsets of the balance fields.

```
// Safe balance access pattern
const currentBalance = account.balances?.current ?? 0;
const availableBalance = account.balances?.available ?? account.balances?.current ?? 0;
```

### Plaid sandbox transactions query works but returns no data when the date range is too narrow

Cause: Plaid's sandbox environment generates synthetic transaction data but only for specific date ranges relative to the item creation date. If the requested start_date and end_date don't overlap with the synthetic data's date range, the transactions array is empty.

Solution: In sandbox mode, use a wider default date range (last 90 days) when testing. Check the Plaid sandbox documentation for the exact date window of synthetic transactions. For production, ensure the start_date is not earlier than the Plaid Item's creation date or the institution's transaction history limit.

## Frequently asked questions

### What happened to Mint, and where did Mint's data go?

Intuit announced in November 2023 that Mint would shut down on January 1, 2024. Users were redirected to Credit Karma, another Intuit product focused on credit scores and financial health monitoring. Mint's transaction history and budgets were not automatically transferred to Credit Karma — users who wanted to preserve their data needed to export it as a CSV from Mint before the shutdown date. Credit Karma does not provide a public API, so it is not a viable data source for Retool integrations.

### Is there a way to import historical Mint data into a Retool dashboard?

If you exported your Mint transaction data as a CSV before the January 2024 shutdown, you can upload that data into a Retool Database, PostgreSQL, or Google Sheets resource. Create a Retool app that reads from that historical dataset alongside forward-looking Plaid transaction data. For transactions after January 2024, use Plaid's /transactions/get endpoint to continue the data history from where Mint left off.

### Can Retool replace Mint for personal finance management?

Retool can replicate Mint's data display capabilities (account balances, transaction history, spending by category, budget tracking) when connected to Plaid. However, Retool is an internal tool builder, not a consumer finance application — it lacks Mint's automated transaction categorization AI, bill reminders, credit score monitoring, and mobile app. For a complete Mint replacement, consider dedicated alternatives like YNAB, Monarch Money, or Copilot. If you need a highly customized financial dashboard that you control and can extend, Retool with Plaid is an excellent choice.

### Does Plaid access provide the same data that Mint had access to?

Plaid provides access to the same underlying bank data that Mint used — checking and savings balances, transaction history, credit card data, and investment accounts. Mint used Yodlee as its original data provider before Intuit acquired it, then migrated to Intuit's own aggregation infrastructure. Plaid is an equivalent service with broad institutional coverage (11,000+ financial institutions in the US) and is currently the most developer-friendly option for building financial data applications.

### What are the costs of using Plaid as a Mint replacement in Retool?

Plaid's free Development tier allows up to 100 live Items (bank connections) at no cost, making it suitable for personal use and small team financial dashboards. The paid Production tier is priced per-Item per-month and varies by product (Transactions, Auth, Identity, etc.). For a personal finance dashboard with a handful of connected accounts, costs are minimal. Review Plaid's current pricing at plaid.com/pricing before moving to production, as pricing may have changed since this guide was written.

---

Source: https://www.rapidevelopers.com/retool-integrations/mint
© RapidDev — https://www.rapidevelopers.com/retool-integrations/mint