How to Integrate Retool with Stripe Connect

Before configuring Retool, create a restricted API key in Stripe specifically for your Retool admin panel. Navigate to the Stripe Dashboard at dashboard.stripe.com, go to Developers → API keys, and click Create restricted key. Name it something identifiable like 'Retool Connect Admin' and grant read-only permissions for the resources your dashboard needs: Connected Accounts (read), Transfers (read), Payouts (read), Disputes (read), and Charges (read). If your Retool app will need to perform write actions like processing refunds or responding to disputes, add those write permissions explicitly. Copy the generated key — you will only see it once. Now open Retool and navigate to the Resources tab. Click Add Resource in the top right. Search for or scroll to find 'Stripe' in the resource list and click it. In the configuration panel: - Name: give it a descriptive name like 'Stripe Connect - Platform' - API Key: paste the restricted key you just created - Environment: select Live or Test depending on which Stripe environment you want to connect to first (create separate resources for each if you need both) Click Save Changes. The resource is now available in the query editor. It's best practice to create two separate Stripe resources — one for your test API key and one for your live API key — and use Retool's resource environments to manage which one apps use in development versus production.

In a Retool app, create a new query and select your Stripe Connect resource. Click the Action Type dropdown and select List Connected Accounts (or search for 'accounts' in the operation search). This maps to Stripe's GET /v1/accounts endpoint, which returns all connected accounts on your platform. In the query parameters that appear below the Action Type, configure: - Limit: 100 (maximum per request; Stripe Connect platforms often have hundreds or thousands of accounts so you may need pagination) - Expand: ['capabilities', 'requirements'] — expanding these fields adds onboarding status details to each account object without requiring separate queries Set the query to Run this query automatically when inputs change with Trigger on page load enabled, so the account list loads when the app opens. After running the query, add a Transformer to reshape the raw Stripe response into a flat format suitable for a Table component. Click the Advanced tab in the query editor, then click Add transformer. Write a JavaScript function that extracts the fields most relevant to your operations team from each account object. Drag a Table component from the Component panel onto the canvas and set its Data source to {{ listAccountsQuery.data }} (or {{ listAccountsQuery.data }} if using a transformer). Configure the table columns to show the most actionable fields: account ID, business name, charges_enabled, payouts_enabled, and a formatted requirements list.

1// JavaScript transformer to reshape Stripe connected accounts response
2// Apply this as a query transformer on the List Connected Accounts query
3const accounts = data; // raw response array from Stripe API
4return accounts.map(account => ({
5  id: account.id,
6  business_name: account.business_profile?.name || account.settings?.dashboard?.display_name || account.id,
7  email: account.email || '',
8  country: account.country,
9  account_type: account.type, // standard, express, or custom
10  charges_enabled: account.charges_enabled,
11  payouts_enabled: account.payouts_enabled,
12  details_submitted: account.details_submitted,
13  created: new Date(account.created * 1000).toLocaleDateString(),
14  outstanding_requirements: (account.requirements?.currently_due || []).join(', ') || 'None',
15  capabilities_card_payments: account.capabilities?.card_payments || 'inactive'
16}));

Stripe Connect's most powerful feature is the ability to make API calls on behalf of a specific connected account to view or manage their data — charges, balance, payouts, and more. In Retool, you implement this using the Stripe-Account header, which tells Stripe to scope the request to a specific connected account ID. Create a new query using your Stripe resource. Select the Action Type (e.g., List Charges to see charges for a specific seller). In the Advanced section of the query editor, find the Additional Headers configuration. Add a header: - Key: Stripe-Account - Value: {{ table1.selectedRow.id }} — this dynamically passes the selected connected account's ID from your accounts table This pattern allows your dashboard to drill down into any connected account by clicking that account's row in the accounts table. The charge list query re-runs automatically (since the input changes when a row is selected) and shows charges belonging only to that connected account. Repeat this pattern for other account-scoped queries: List Payouts (to show a specific account's payout history), Get Balance (to show their current platform balance), and List Disputes (to show disputes on that account's charges). All of these queries use the same Stripe-Account header technique. For platform-level transfers (money moving between your platform and connected accounts), do NOT use the Stripe-Account header — List Transfers without that header shows transfers at the platform level, which is what finance teams typically need for reconciliation.

1// Query configuration for account-scoped charges
2// Add this in the Advanced > Additional Headers section of the query
3{
4  "Stripe-Account": "{{ table1.selectedRow.id }}"
5}
6
7// JavaScript transformer for the charges response
8const charges = data;
9return charges.map(charge => ({
10  id: charge.id,
11  amount: '$' + (charge.amount / 100).toFixed(2),
12  currency: charge.currency.toUpperCase(),
13  status: charge.status,
14  description: charge.description || '',
15  customer_email: charge.billing_details?.email || '',
16  created: new Date(charge.created * 1000).toLocaleString(),
17  refunded: charge.refunded,
18  dispute: charge.disputed ? 'Yes' : 'No'
19}));

Platform-level transfers and payouts are critical for finance teams reconciling what money went where. These queries operate at the platform level (no Stripe-Account header needed) and show the flow of funds between your platform and connected accounts. Create a query using List Transfers (platform-level) to show all transfers from your platform to connected accounts. Configure parameters: - Limit: 100 - Created[gte]: {{ dateRangePicker.startDate }} — filter by creation date start - Created[lte]: {{ dateRangePicker.endDate }} — filter by creation date end Drag a DateRangePicker component onto the canvas and set the default range to the last 30 days. This gives finance teams an immediate filtered view without loading all historical data. For the payouts view (money moving from Stripe to your bank account or connected accounts' bank accounts), create a second query using List Payouts. This is a separate endpoint that shows settlement batches. Add a Select component for filtering by payout status: paid, pending, in_transit, failed, canceled. Create a transformer that calculates summary statistics from the transfer results — total volume, count by status, and average transfer amount. Bind these to Text components at the top of the page as summary cards, giving finance teams a quick snapshot before diving into the detailed table. For complex integrations that need to combine Stripe Connect data with your internal accounting records or cross-reference multiple data sources, RapidDev's team can help architect multi-resource Retool apps that join Stripe data with your internal database seamlessly.

1-- If you also have an internal database resource, use this pattern
2-- to enrich Stripe transfer data with your internal account names
3-- Run this as a separate database query, then join in a JS transformer
4SELECT
5  account_id,
6  seller_name,
7  seller_tier,
8  signup_date
9FROM marketplace_accounts
10WHERE account_id = ANY({{ transfersQuery.data.map(t => t.destination) }}::text[]);

Disputes are high-priority items that require timely responses — missed deadlines result in automatic losses. Build a dedicated disputes panel that surfaces all open disputes across connected accounts with their evidence deadlines prominently displayed. Create a query using List Disputes at the platform level. In the query parameters: - Status: can be filtered by 'needs_response', 'under_review', 'warning_needs_response' - Add an Expand parameter for 'charge' and 'payment_intent' to get the associated payment details in the same response Add a Select component for filtering disputes by status, and wire it to the query parameter: {{ disputeStatusFilter.value }}. Create a transformer that adds a calculated 'days_until_deadline' field based on the evidence_due_by timestamp from each dispute object. This lets you sort the table by urgency and highlight disputes with fewer than 7 days remaining using Retool's Table conditional row styles. In the Table component Inspector, find Conditional Row Styles and add a rule: when {{ self.days_until_deadline <= 7 }}, apply a red background color to flag urgent disputes. Add a second rule for disputes due within 30 days with an orange or yellow background. Drag a form panel or Modal component for the dispute detail view. When a dispute row is selected, the detail panel shows the full dispute object including the reason, charge amount, connected account, and evidence requirements. Add a Text area component for internal notes and a button that updates an internal disputes tracking table in your database with the note content — creating an audit trail outside of Stripe's system.

1// JavaScript transformer for disputes with urgency calculation
2const disputes = data;
3const now = Date.now() / 1000; // current time in Unix seconds
4
5return disputes
6  .map(dispute => ({
7    id: dispute.id,
8    amount: '$' + (dispute.amount / 100).toFixed(2),
9    currency: dispute.currency.toUpperCase(),
10    reason: dispute.reason,
11    status: dispute.status,
12    connected_account: dispute.charge?.on_behalf_of || 'Platform',
13    charge_id: dispute.charge?.id || '',
14    evidence_due: dispute.evidence_details?.due_by
15      ? new Date(dispute.evidence_details.due_by * 1000).toLocaleDateString()
16      : 'N/A',
17    days_until_deadline: dispute.evidence_details?.due_by
18      ? Math.ceil((dispute.evidence_details.due_by - now) / 86400)
19      : null,
20    created: new Date(dispute.created * 1000).toLocaleDateString()
21  }))
22  .sort((a, b) => (a.days_until_deadline || 999) - (b.days_until_deadline || 999));