How to build Polar revenue dashboards in Metabase

Polar is a merchant-of-record billing platform for developers and SaaS — subscriptions, one-time products, and digital benefits, with tax handled for you. Metabase is where you turn that into shared revenue dashboards. Because Metabase reads from SQL databases, the reliable way to connect them is a small pipeline: sync Polar into a database or warehouse on a schedule, then point Metabase at it. This guide walks through that path end to end — including a free option with no paid connector.

How do you connect Polar to Metabase?

Metabase connects to SQL databases and warehouses — not to SaaS APIs directly, and there's no native Polar connector. So connecting Polar to Metabase means one thing: run a small pipeline that copies Polar data into a database on a schedule, then connect Metabase to that database. Once the data lands, the models, metrics, and SQL later in this guide all work.

The good news: this doesn't require a paid tool. Use a managed connector if you want zero maintenance, or a free, code-based sync you host yourself — both are covered in Build the pipeline below, and in more depth in our guide to building a data pipeline.

What can you analyze from Polar data in Metabase?

• MRR and ARR — recurring revenue now and its monthly movement
• Net revenue — what lands after Polar fees and tax (merchant of record)
• Churn and retention — customer and revenue churn, gross and net retention
• Orders and products — subscription vs. one-time revenue by product
• LTV and ARPU — value per customer and per product
• Refunds and disputes — their impact on net revenue

Which Polar dashboards should you build in Metabase?

How do you build the Polar → Metabase pipeline?

For dashboards that need history and reliability, land Polar data in a database first, then connect Metabase to that database.

Connector options

• dlt / custom pipeline (free, code) — wrap the Polar API in a Python pipeline when you want full control over shaping and scheduling.
• Polar API (free, raw) — paginate customers, subscriptions, orders, and products into your own pipeline.
• Webhooks (free, events) — stream order and subscription lifecycle events into a table for near-real-time dashboards.

Notes

• Land raw tables first, then build clean models on top.
• Amounts are typically in the smallest currency unit — divide in a model layer.
• Separate gross (customer paid) from net (after Polar fees and tax) — they answer different questions.
• MRR is derived, not stored: build it from active subscriptions and normalized prices.

Can you generate a Polar dashboard with AI?

Yes — and once Polar data is synced into a database, this is the fastest way to a strong first draft. First give an AI assistant a way to read your Metabase schema and create questions and dashboards, then paste the prompt below. It builds the dashboard from your database tables and tells the agent to skip metrics the schema can't support instead of faking them.

Two ways to let an assistant query and build in Metabase

Both connect to a Metabase instance that's already pointed at your synced database — the pipeline above moves the data; these just let the assistant read and write Metabase. Pick whichever fits your setup:

Set up the Metabase MCP server

Enable it under Admin → AI → MCP, then point your client at the endpoint:

# Metabase built-in MCP (replace with your instance URL)
claude mcp add --transport http metabase https://your-metabase.example.com/api/metabase-mcp

{
  "mcpServers": {
    "metabase": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://your-metabase.example.com/api/metabase-mcp"]
    }
  }
}

Clients with native remote support can use a "url" field instead of the mcp-remote bridge. Confirm the current endpoint in the Metabase MCP docs.

Set up the Metabase CLI

Install it globally, then authenticate once (the binary is mb):

# Install the CLI (the binary is `mb`)
npm install -g @metabase/cli

# Authenticate once — opens your browser on Metabase v62+, or use an API key
mb auth login --url https://your-metabase.example.com
mb auth status

On Metabase v62+ mb auth login opens your browser; older servers fall back to an API key. A terminal-based assistant can then inspect your schema (mb db schemas, mb table get --include fields) and create content (mb card create, mb dashboard create) against the synced tables.

Prompt: build the Polar Revenue Overview dashboard

With MCP or the CLI connected, paste this into your assistant to generate the dashboard:

Create a polished Metabase dashboard for Polar revenue analytics using the
available Polar tables in this database.

Goal: Help founders and finance leaders understand recurring revenue, net
revenue after fees/tax, subscriptions, churn, and product mix from Polar data.

First, inspect the schema and identify the available Polar tables. Do not assume
exact table names. Map the raw data into these analytical concepts where
possible: Customers, Subscriptions, Products, Prices, Orders, Benefits,
Discounts, and Refunds.

Important:
- Build the dashboard from durable database/warehouse tables (Polar API/webhooks).
- Polar is a merchant of record: separate gross revenue from net (after Polar
  fees and tax). Report net for what the business keeps.
- Compute MRR from active subscriptions, normalizing every price to a monthly
  amount and converting to a single reporting currency.
- Separate subscription revenue from one-time product sales.
- Exclude refunds from net revenue and show their impact separately.
- Do not claim Metabase connects natively to Polar unless that is explicitly true
  in this environment.

Dashboard title: Polar Revenue Overview

Sections:
1. Executive summary (KPI cards): MRR; ARR; Net revenue this month; Active
   subscriptions; Net new MRR; Revenue churn %.
2. MRR & net revenue: MRR movement by month; Gross vs. net revenue.
3. Subscriptions & churn: Active subscriptions by product; Customer vs. revenue
   churn; New vs. canceled.
4. Orders & products: Orders and revenue by product; Subscription vs. one-time
   split; Checkout conversion.
5. Cohorts & LTV: Revenue retention by cohort; Cumulative LTV; ARPU by product.

Filters: Product, Price, Currency, Country, Date range.

Before finalizing, create or recommend reusable Metabase models:
modeled_polar_subscriptions, modeled_polar_orders, and modeled_polar_mrr (a
monthly per-subscription MRR model).

Output: Build the dashboard if you have permission; otherwise provide the exact
questions, SQL, model definitions, and layout. Include caveats for any metric
that cannot be calculated from the available schema. Reconcile totals against
the Polar dashboard. Keep it practical, dense, and executive-readable. Avoid
vanity metrics.

How should you model Polar data in Metabase?

Core tables

Modeling advice

• Build a modeled_polar_mrr table: one row per subscription per month with a normalized monthly amount.
• Model both gross and net revenue so finance sees what lands after fees/tax.
• Separate one-time product orders from recurring subscription revenue so they don't inflate MRR.
• Normalize all prices to a monthly figure and a single reporting currency.
• Reconcile modeled revenue against the Polar dashboard.

Which Polar metrics should you track in Metabase?

What SQL powers Polar dashboards in Metabase?

These assume the modeled tables above (PostgreSQL dialect, amounts in minor units). Adjust identifiers to match your schema.

-- Requires a monthly MRR model built from Polar subscriptions + prices
SELECT
  ROUND(SUM(mrr), 2)       AS mrr,
  ROUND(SUM(mrr) * 12, 2)  AS arr,
  COUNT(*)                 AS active_subscriptions
FROM modeled_polar_mrr
WHERE month = date_trunc('month', CURRENT_DATE);

-- Gross vs. net revenue (net = after Polar fees and tax)
SELECT
  date_trunc('month', created_at)                     AS month,
  ROUND(SUM(amount) / 100.0, 2)                       AS gross_revenue,
  ROUND(SUM(amount - tax_amount - fee_amount) / 100.0, 2) AS net_revenue
FROM orders
WHERE status = 'paid'
GROUP BY 1
ORDER BY 1;

SELECT
  p.name                                      AS product,
  COUNT(*)                                    AS orders,
  ROUND(SUM(o.amount) / 100.0, 2)             AS gross_revenue,
  COUNT(*) FILTER (WHERE o.is_subscription)   AS recurring_orders
FROM orders o
JOIN products p ON p.id = o.product_id
WHERE o.status = 'paid'
GROUP BY p.name
ORDER BY gross_revenue DESC;

What are common mistakes when analyzing Polar in Metabase?

Related

Related analytics

Related metrics

Related integrations

FAQ