How to build Recurly revenue dashboards in Metabase

Recurly runs your subscription management, billing, and dunning. Metabase is where you turn that billing activity into shared, trustworthy dashboards. Because Metabase reads from SQL databases, the reliable way to connect them is a small pipeline: sync Recurly 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 Recurly to Metabase?

Metabase connects to SQL databases and warehouses — not to SaaS APIs directly, and there's no native Recurly connector. So connecting Recurly to Metabase means one thing: run a small pipeline that copies Recurly 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 Recurly data in Metabase?

• MRR and ARR — recurring revenue now and its monthly movement
• Churn and retention — customer and revenue churn, gross and net retention
• Expansion and contraction — plan changes, add-ons, and quantities
• Failed payments and dunning — declines, recovery, and involuntary churn
• Trials and conversion — trial-to-paid rate and time to convert
• LTV and ARPU — value per customer and per account
• Cohort revenue — how each signup cohort retains and grows

Which Recurly dashboards should you build in Metabase?

How do you build the Recurly → Metabase pipeline?

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

Connector options

• dlt (free, code) — write a Python pipeline against the Recurly v3 API for full control.
• Recurly API (v3) (free, raw) — the source of truth; paginate resources and sync on a schedule.
• Recurly export files (first-party) — scheduled data exports you can load into your warehouse.
• Airbyte — has a Recurly source covering accounts, subscriptions, invoices, transactions, plans, and more. Free if you self-host the open-source version; paid on Airbyte Cloud.

Notes

• Land raw tables first, then build clean models on top.
• Recurly v3 API amounts are decimals in the major currency unit — don't divide by 100 unless your pipeline stored minor units.
• A subscription's state plus expires_at defines whether it's still billing; use both.
• MRR is derived: build it from active subscriptions and their plans.

Can you generate a Recurly dashboard with AI?

Yes — and once Recurly 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 Recurly Revenue Overview dashboard

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

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

Goal: Help founders and finance leaders understand recurring revenue, churn,
retention, failed payments, and cohort economics from Recurly data.

First, inspect the schema and identify the available Recurly tables. Do not assume
exact table names. Map the available raw tables into these analytical concepts
where possible: Accounts, Subscriptions, Subscription add-ons, Plans, Invoices,
Line items, Transactions, and Coupon redemptions.

Important:
- Build the dashboard from durable database/warehouse tables.
- Compute MRR from active subscriptions, normalizing every plan to a monthly amount
  (divide annual by 12, etc.). Recurly v3 amounts are already in major currency
  units (decimals), so do not divide by 100 unless your pipeline stored minor units.
- Report revenue in a single reporting currency; if multiple currencies exist,
  convert with a documented rate or caveat the mix.
- Separate voluntary churn from involuntary (failed-payment) churn.
- Exclude one-time charges and setup fees from MRR unless explicitly asked.
- Do not claim Metabase connects natively to Recurly unless that is explicitly
  true in this environment.

Dashboard title: Recurly Revenue Overview

Sections:
1. Executive summary (KPI cards): MRR; ARR; Active subscriptions; Net new MRR this
   month; Gross revenue churn %; Net revenue retention (only if MRR-movement data
   can be derived).
2. MRR movement: New, expansion, contraction, and churned MRR by month.
3. Churn & retention: Customer vs. revenue churn by month; Gross vs. net retention;
   Churn by plan; Trial-to-paid conversion.
4. Failed payments & dunning: Failed transactions and $ at risk; Dunning recovery
   rate; Declines by reason; Past-due subscriptions by age.
5. Cohorts & LTV: Revenue retention by signup-month cohort; Cumulative LTV by
   cohort; ARPU by plan.

Filters: Plan, Billing interval, Currency, Account state, Date range.

Before finalizing, create or recommend reusable Metabase models:
modeled_recurly_accounts, modeled_recurly_subscriptions, modeled_recurly_invoices,
modeled_recurly_transactions, and modeled_recurly_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 Recurly's
analytics. Keep it practical, dense, and executive-readable. Avoid vanity metrics.

How should you model Recurly data in Metabase?

Core tables

Modeling advice

• Build a modeled_recurly_mrr table: one row per subscription per month with a normalized monthly amount.
• Normalize all plans to a monthly figure (annual ÷ 12, etc.) and to one reporting currency.
• Define subscription state once (active / canceled / expired / future) and combine with expires_at to decide who is still billing.
• Keep setup fees and one-time charges out of MRR.
• Reconcile modeled MRR against Recurly's analytics before trusting it.

Which Recurly metrics should you track in Metabase?

What SQL powers Recurly dashboards in Metabase?

These assume the modeled tables above (PostgreSQL dialect, v3 amounts in major currency units). Adjust identifiers to match your warehouse.

SELECT
  ROUND(SUM(
    CASE p.interval_unit
      WHEN 'years'  THEN s.unit_amount / 12.0 / NULLIF(p.interval_length, 0)
      WHEN 'months' THEN s.unit_amount / NULLIF(p.interval_length, 0)
    END * s.quantity
  ), 2) AS mrr_now
FROM subscriptions s
JOIN plans p ON p.id = s.plan_id
WHERE s.state IN ('active', 'canceled')  -- canceled but not yet expired still bills
  AND (s.expires_at IS NULL OR s.expires_at > CURRENT_DATE);

WITH months AS (
  SELECT generate_series(
    date_trunc('month', CURRENT_DATE - INTERVAL '11 months'),
    date_trunc('month', CURRENT_DATE),
    INTERVAL '1 month'
  ) AS month
)
SELECT
  m.month,
  COUNT(*) FILTER (
    WHERE date_trunc('month', s.expires_at) = m.month
  ) AS churned_subscriptions,
  COUNT(*) FILTER (
    WHERE s.activated_at <= m.month
      AND (s.expires_at IS NULL OR s.expires_at > m.month)
  ) AS active_at_month_start
FROM months m
CROSS JOIN subscriptions s
GROUP BY m.month
ORDER BY m.month;

SELECT
  date_trunc('week', t.created_at) AS week,
  COUNT(*)                          AS failed_transactions,
  ROUND(SUM(t.amount), 2)           AS dollars_at_risk,
  t.status_message
FROM transactions t
WHERE t.status = 'declined'
  AND t.created_at >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY 1, t.status_message
ORDER BY 1, dollars_at_risk DESC;

What are common mistakes when analyzing Recurly in Metabase?

Related

Related analytics

Related metrics

Related integrations

FAQ