How to build a Stripe cashflow dashboard in Retool

A Retool Stripe cashflow dashboard gives finance teams a live, shareable view of revenue, payouts, MRR (monthly recurring revenue), and cash position — connected directly to the Stripe API, without the weekly cycle of CSV exports, spreadsheet rebuilds, and Slack-shared files.

But Stripe's dashboard was built for payment operations, not finance operations. It's excellent at showing you whether a charge succeeded and what your dispute rate looks like. It's not built for the questions your finance team actually asks every week: What's our cash position right now? What's MRR (monthly recurring revenue) doing? What's hitting our bank account on Thursday? How much did we lose to refunds this month?

If you're involved in any aspect of finance in the B2B world, you know the magic that is Stripe. It turned what used to be weeks of merchant account paperwork and payment gateway contracts into a handful of API calls and a dashboard.

Those questions send people into the same loop: log in to Stripe, export CSVs, paste them into a spreadsheet, rebuild the formulas, share them over Slack, do it again next week.

This guide walks through the full build: connecting Stripe, querying the right endpoints, and assembling a dashboard your finance team will actually use.

Why build your Stripe cashflow dashboard in Retool

Retool connects to the Stripe API and lets you build a live, shareable cashflow dashboard that combines Stripe revenue data with other sources, with no CSV exports, no manual updates, and full team access.

Direct Stripe API connection: live data, always current

Retool has a native Stripe integration with a dedicated resource type. You create a Stripe resource, provide your API key, and you're connected.

From there, you can query any Stripe endpoint (Charges, Subscriptions, Balance, Payouts, Invoices, Refunds, and more) through a structured operation picker instead of writing raw HTTP requests. Every query pulls live data from Stripe's API when the app loads or a user triggers a refresh. No ETL (extract-transform-load) pipeline,, no stale exports, no sync lag.

One dashboard for Stripe, Salesforce, QuickBooks, and your database

Most finance teams don't live in Stripe alone. You might need to cross-reference subscription revenue with Salesforce sales data, match payouts to QuickBooks entries, or pull customer metadata from your Postgres database. Retool lets you query multiple data sources in the same app and join the results.

A single dashboard view can pull Stripe charges alongside your internal database records, then use a JavaScript transformer to merge and compare them. This is where a custom dashboard earns its keep over Stripe's native reporting.

Live MRR, ARR, and cash position without manual calculation

Stripe's API exposes raw objects: charges, subscriptions, invoices, and payouts. It doesn't give you MRR, net revenue after refunds, or cash position as calculated fields. In Retool, you can attach JavaScript transformers to any query result. Pull active subscriptions from Stripe, normalize monthly and annual plans to a single MRR figure, calculate refund rate as a percentage of gross revenue, and derive net cash position from available and pending balances.

// Retool JavaScript transformer: calculate MRR from active subscriptions
const subscriptions = {{ listActiveSubscriptions.data.data }};

const mrr = subscriptions.reduce((sum, sub) => {
  const price = sub.items.data[0].price;
  const amount = price.unit_amount;

  if (price.recurring.interval === 'year') return sum + (amount / 12);
  if (price.recurring.interval === 'month') return sum + amount;
  return sum + amount;
}, 0);

return {
  mrr: (mrr / 100).toFixed(2),
  arr: ((mrr * 12) / 100).toFixed(2),
  activeCount: subscriptions.length,
};

These transformers run whenever the underlying query refreshes, so your derived metrics stay current without manual recalculation.

Shareable with your finance team, with role-based access

A dashboard only works if the people who need it can access it. Retool apps support role-based permissions, so your finance team can view the data without needing Stripe Dashboard access (and the API key exposure that comes with it).

You control who can view the app, who can edit queries, and who can trigger actions like issuing refunds. For teams on Retool's Enterprise plan, you can also configure separate resource environments so that the same app connects to Stripe test mode in staging and to Stripe live mode in production—so you can safely develop and test changes to the app without touching real data or real money.

Core components of a Retool Stripe cashflow dashboard

A Retool Stripe cashflow dashboard typically includes a cash position summary, MRR and ARR trend charts, a payout timeline, churn and refund metrics, and a transaction search and filter table.

Cash position summary. The top of your dashboard should answer the question your CFO asks every Monday: "How much cash do we have, and what's coming?" The Stripe Balance API (https://retool.com/v1/balance) returns your available balance, pending balance, and funds in transit, broken down by currency. Display these in a row of stat components at the top of the app.
MRR / ARR trend chart. A line or bar chart showing monthly recurring revenue over time, calculated from active subscriptions. Since Stripe doesn't expose MRR as a native field, you'll calculate it by aggregating subscription data (more on this in the build steps below). Add ARR as a secondary metric by multiplying MRR by 12 (Retool also has a revenue dashboard template if you want a starting point for this.).
Payout timeline. The Payouts API (https://retool.com/v1/payouts) returns every transfer Stripe has made (or will make) to your bank account, including the amount, status, and expected arrival date. A table sorted by arrival date gives your finance team a clear view of upcoming cash inflows.
Churn and refund tracker. Refunds and cancellations erode revenue. Pull refund data from https://retool.com/v1/refunds and canceled subscriptions from https://retool.com/v1/subscriptions?status=canceled to build a summary of net revenue health. Display refund volume, refund rate (as a percentage of gross revenue), and subscription cancellations over time.
Transaction table. Every finance dashboard needs a detailed transaction view. The Charges API (https://retool.com/v1/charges) returns payment history with customer info, amount, status, and metadata. Bind this to a Retool table component with search, status, and date-range filters, and pagination for large datasets.
(Optional) Combined view. If you connect a second data source (Postgres, QuickBooks, or another accounting tool), you can build a reconciliation view that matches Stripe payouts against your general ledger entries. This is where Retool's ability to join data across sources becomes especially valuable.

Step-by-step: Building your Stripe cashflow dashboard in Retool

To build a Stripe cashflow dashboard in Retool, connect Stripe as a resource using your Stripe secret key, query the Balance, Charges, and Payouts endpoints, and bind the results to chart and table components. Here is what we’re going to build:

We’re going to walk through this step by step, but there is an easier way to create this dashboard. AI. We can create it using a prompt like this directly in Retool:

Build a Stripe cashflow dashboard with these sections:

- Cash position summary row with 3 stat components showing available balance, pending balance, and total from the Balance endpoint, all formatted as USD.

- MRR and ARR stats calculated from active subscriptions, normalizing annual plans to monthly, plus a bar chart grouping MRR by product tier.

- Payout timeline table from the Payouts endpoint with amount, status, arrival date, and a date range filter.

- Churn and refund metrics with total refund volume and count stats from the Refunds endpoint, plus a small recent refunds table.

- Full-width transaction search table from the Charges endpoint with columns for amount, customer email, status, description, and created date, with text search, status filter, and date range picker.

- Add a Refresh All button in the header and run all queries on page load.

Retool will generate the layout, queries, and components. You'll likely need to adjust the MRR transformer logic by hand (see Step 3 below), but the rest should work out of the box.

Step 1: Connect Stripe to Retool

First, you need to hook up Stripe so you can access all the data. All you’ll need from Stripe is an API key. You can get this from Developers > API keys:

You want the secret key that starts with sk_test_. Here, we’re in test mode, which is an excellent way to test out Stripe and integrations before going live with real data. You can seed realistic SaaS data (customers, subscriptions, charges, refunds) using the Stripe API or the Dashboard.

In Retool, head to Resources > Create New > Stripe. Give the resource a name (e.g., "Stripe - Production" or "Stripe - Test") and paste in your Stripe secret API key.

Click Test connection to verify, then Create resource. You now have a Stripe resource available to any app in your Retool org.

With this single Stripe connection, you can build anything on top of Stripe with Retool. Here is a walkthrough on building a Stripe card management dashboard that covers similar patterns.

Step 2: Query the Balance endpoint for cash position

Head to Apps > Create > App. This will give you the App editor. We want to start by creating a Stripe query. In the left-hand menu bar, head to code > + then select your Stripe resource.

The first query returns the balance from our Stripe account. Choose the https://retool.com/v1/balance operation, which returns your available and pending balances by currency.

This returns the raw data in cents. To get it in the format you want, you can rework it with JavaScript:

const bal = {{ getStripeBalance.data }};
const availableCents = bal?.available?.[0]?.amount ?? 0;
const pendingCents = bal?.pending?.[0]?.amount ?? 0;
return {
  availableCents,
  pendingCents,
  totalCents: availableCents + pendingCents,
  available: availableCents / 100,
  pending: pendingCents / 100,
  total: (availableCents + pendingCents) / 100 };

This gives you available, pending, and total balance figures. These will be the highlight numbers at the top of our dashboard:

Each of these is a card containing a statistic component with the value set by the corresponding balance data:

Format them as currency. These give your finance team the at-a-glance cash position they check first.

Step 3: Build an MRR chart

Stripe doesn't expose MRR directly, so this step requires the most manual work.

First, you need to query active subscriptions. Create a Stripe query using Subscriptions > List subscriptions with status=active and a high limit (100 per page). If you have more than 100 subscriptions, you'll need to paginate.

The output can then be used to calculate MRR with a JavaScript transformer. Add a transformer that processes the subscription data:

const subs = {{ listStripeSubscriptions.data }}?.data ?? [];

let mrrCents = 0;

for (const sub of subs) {
  const item = sub?.items?.data?.[0];
  const price = item?.price;
  const unitAmount = price?.unit_amount ?? 0; // cents
  const interval = price?.recurring?.interval;
  const intervalCount = price?.recurring?.interval_count ?? 1;
  const quantity = item?.quantity ?? 1;

  // Normalize to monthly
  let monthlyCents = unitAmount * quantity;
  if (interval === 'year') {
    monthlyCents = monthlyCents / 12;
  } else if (interval === 'week') {
    monthlyCents = monthlyCents * (52 / 12);
  } else if (interval === 'day') {
    monthlyCents = monthlyCents * (365 / 12);
  } else if (interval === 'month') {
    // handle multi-month intervals (e.g. every 3 months)
    monthlyCents = monthlyCents / intervalCount;
  }

  mrrCents += monthlyCents;
}

return {
  mrrCents,
  mrr: mrrCents / 100,
  arr: mrrCents * 12 / 100,
  subscriptionCount: subs.length };

This transformer loops through every active subscription, reads its price and billing interval, normalizes each to a monthly amount (dividing annual plans by 12 and multiplying weekly plans by 52/12), and returns the totals for MRR, ARR, and a subscription count.

As with the balance numbers, you can display the current MRR and ARR values in a statistic component.

MRR is also a great opportunity for visualization. If you have historical subscription data, you can show an MRR trend chart over time. Query invoices by month using https://retool.com/v1/invoices with created date filters, then aggregate paid invoice amounts per month. Bind the result to a line chart component.

Here, we’ll visualize our MRR by plan. We can transform our data in MMR by plan with JavaScript again:

const subs = {{ listStripeSubscriptions.data }}?.data ?? [];
const products = {{ listStripeProducts.data }}?.data ?? [];

const productNameById = {};
for (const p of products) {
  if (p?.id) productNameById[p.id] = p?.name ?? p.id;
}

const mrrByTierCents = {};

for (const sub of subs) {
  const item = sub?.items?.data?.[0];
  const price = item?.price;
  const unitAmount = price?.unit_amount ?? 0;
  const interval = price?.recurring?.interval;
  const intervalCount = price?.recurring?.interval_count ?? 1;
  const quantity = item?.quantity ?? 1;

  let monthlyCents = unitAmount * quantity;
  if (interval === 'year') {
    monthlyCents = monthlyCents / 12;
  } else if (interval === 'week') {
    monthlyCents = monthlyCents * (52 / 12);
  } else if (interval === 'day') {
    monthlyCents = monthlyCents * (365 / 12);
  } else if (interval === 'month') {
    monthlyCents = monthlyCents / intervalCount;
  }

  const productId = price?.product ?? 'unknown';
  const tierName = productNameById[productId] ?? productId;

  mrrByTierCents[tierName] = (mrrByTierCents[tierName] ?? 0) + monthlyCents;
}

const tiers = Object.keys(mrrByTierCents).sort((a, b) => (mrrByTierCents[b] ?? 0) - (mrrByTierCents[a] ?? 0));
const mrr = tiers.map((t) => (mrrByTierCents[t] ?? 0) / 100);

return { tiers, mrr };

This performs the same monthly normalization as the previous transformer, but instead of a single total, it buckets each subscription's MRR under its product name (Starter, Pro, Enterprise, etc.) and sorts them from highest to lowest revenue. The output is two arrays: tier names and their MRR values, which you can drop straight into a bar chart.

We can then bind this data to a chart component:

This sets the tiers on the X axis and the MRR by tier on the Y axis, with the type set as Bar for clear delineation.

Step 4: Add the payout timeline

Create a Stripe query for Payouts > List payouts and wire it up to a Table component.

You'll want columns for amount, status, arrival date, and description, sorted by arrival date so the newest payouts show up first. This is the view your finance team checks when they want to know what's landing in the bank account this week.

For filtering, drop a Date Range component above the table and pass the selected start and end dates as created[gte] and created[lte] on the query.

const payouts = {{ listStripePayouts.data }}?.data ?? [];
const start = {{ payoutsDateRange.value }}?.start;
const end = {{ payoutsDateRange.value }}?.end;

const startUnix = start ? Math.floor(new Date(start).getTime() / 1000) : null;
const endUnix = end ? Math.floor(new Date(end).getTime() / 1000) : null;

const filtered = payouts.filter((p) => {
  const created = p?.created ?? 0;
  if (startUnix != null && created < startUnix) return false;
  if (endUnix != null && created > endUnix) return false;
  return true;
});

filtered.sort((a, b) => (b?.arrival_date ?? 0) - (a?.arrival_date ?? 0));
return filtered;

That lets your team narrow down to a specific pay period without scrolling through months of history.

Step 5: Build the transaction search table

This is the workhorse view, the one your team will use to look up a specific charge or track down a payment issue. Create a Stripe query for Charges > List charges with a reasonable limit (25-50 per page). Bind it to a table component with columns for: amount, customer email, status, description, and created date.

Above the table, add a Text Input for email search, a Select dropdown for status (All, Succeeded, Pending, Failed), and a Date Range picker.

Rather than passing these filters as query parameters (which can be finicky with Stripe's native resource), this transformer handles all the filtering client-side.

const charges = {{ listStripeCharges.data }}?.data ?? [];

const emailNeedle = ({{ chargesEmailSearch.value }} ?? '').trim().toLowerCase();
const statusFilter = {{ chargesStatusFilter.value }} ?? 'all';
const start = {{ chargesDateRange.value }}?.start;
const end = {{ chargesDateRange.value }}?.end;

const startUnix = start ? Math.floor(new Date(start).getTime() / 1000) : null;
const endUnix = end ? Math.floor(new Date(end).getTime() / 1000) : null;

return charges.
filter((c) => {
  const email = (c?.billing_details?.email ?? '').toLowerCase();
  const status = c?.status ?? '';
  const created = c?.created ?? 0;

  if (emailNeedle && !email.includes(emailNeedle)) return false;

  if (statusFilter !== 'all' && status !== statusFilter) return false;

  if (startUnix != null && created < startUnix) return false;
  if (endUnix != null && created > endUnix) return false;

  return true;
}).
sort((a, b) => (b?.created ?? 0) - (a?.created ?? 0));

It takes the full list of charges, checks each one against whatever the user has typed or selected, filters out anything that doesn't match, and sorts the results in newest-first order.

Step 6: Add churn and refund metrics

This section gives your finance team the other side of the revenue picture. Create two queries: one for Refunds > List refunds and another for Subscriptions > List subscriptions with status=canceled.

For refunds, add a transformer that sums up the total refund volume and count:

const refunds = {{ listStripeRefunds.data }}?.data ?? [];

let totalCents = 0;
for (const r of refunds) totalCents += r?.amount ?? 0;

return {
  totalCents,
  total: totalCents / 100,
  count: refunds.length,
  last10: refunds.
  slice().
  sort((a, b) => (b?.created ?? 0) - (a?.created ?? 0)).
  slice(0, 10) };

Then display both as Statistic components:

If you want a refund rate (which your CFO probably does), divide the total refund amount by the total charge amount over the same period. For canceled subscriptions, a simple count works as a Statistic component, or you can show them in a small Table if your team wants to see which customers churned and when.

Step 7: (Optional) Join with accounting data for reconciliation

This is where a custom dashboard starts pulling ahead of anything Stripe offers natively. Retool can query multiple data sources in the same app, so you can layer in context that Stripe doesn't have. A few examples of what teams commonly add:

Accounting reconciliation. Connect your accounting system (QuickBooks, Xero, or a Postgres database backing your GL) and pull ledger entries alongside Stripe payouts. A JavaScript transformer can match payout amounts against ledger entries and flag discrepancies, replacing the manual spreadsheet reconciliation most finance teams grind through every week.
CRM data for revenue context. Connect Salesforce or HubSpot to tie subscription revenue back to deal size, sales rep, or customer segment. This turns your cash flow dashboard into something closer to a revenue intelligence tool, where your finance team can see not just how much MRR a customer generates, but how they got there.
Internal databases for customer health. If you store product usage, support ticket counts, or NPS scores in Postgres or MySQL, you can surface those alongside Stripe billing data. A customer paying $249/mo who hasn't logged in for three weeks looks different from one who's active daily, and that context helps your team prioritize retention work before churn shows up in the numbers.

To add any of these, go back to Resources > Create New in Retool and connect the relevant integration. From there, you can query it in the same app and join the results with your Stripe data using transformers.

Step 8: Set permissions and share with finance

The last step is getting it into your team's hands. Hit Share in the app settings and add your finance team members. Retool lets you set view-only or edit access per user, so your CFO can check the numbers every morning without accidentally breaking a query.

If your team is the type that wants a Monday morning cash position email instead of logging into another tool, you can set up a Workflow that runs on a schedule, pulls the key metrics, and sends a summary to Slack or email. That way, the dashboard is there when people want to dig in, but the headline numbers come to them automatically.

What's next

Two extensions stand out once the core build is done: AI-assisted chargeback workflows and additional Stripe endpoint coverage. You can add AI agent workflows for tasks like automated chargeback responses, where a Retool agent pulls dispute details from Stripe and drafts a response using your historical win/loss data. You can also connect additional Stripe endpoints (Invoices, Disputes, Customers) to expand the dashboard as your finance team's needs evolve.

These financial use cases are among the most common internal tool workflows that teams replace when they move to Retool. The full build, from connecting Stripe to sharing with your team, takes a few hours. When it's done, your finance team has a single place to check cash position, verify upcoming payouts, and track MRR — without waiting on a CSV export or asking anyone for Stripe access.

Get started with Retool by connecting your Stripe account to begin building.