How to build Maxio revenue dashboards in Metabase

Maxio (the combination of Chargify and SaaSOptics) handles subscription billing and SaaS financial operations — subscriptions, components, invoices, and revenue recognition. Metabase is where you turn that into shared dashboards for MRR, churn, retention, and billings. Because Metabase reads from SQL databases, the reliable way to connect them is a small pipeline: sync Maxio 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 Maxio to Metabase?

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

• MRR and ARR — recurring revenue now and its monthly movement
• Churn and retention — logo and revenue churn, gross and net retention
• Billings and AR — invoiced revenue, accounts receivable, and DSO
• Usage and components — metered and add-on revenue
• Revenue recognition — recognized vs. deferred revenue
• Failed payments and dunning — involuntary churn and recovery

Which Maxio dashboards should you build in Metabase?

How do you build the Maxio → Metabase pipeline?

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

Connector options

• dlt (free, code) — wrap the Maxio APIs in a small Python pipeline for incremental, no-vendor loads. The lightest path to a maintainable sync.
• Maxio APIs (first-party) — the Advanced Billing (Chargify) APIs for subscriptions, components, and invoices.
• Exports — scheduled CSV/data exports for subscriptions, invoices, and transactions.
• Managed ETL (paid, managed) — connectors and reverse-ETL tools can pull Maxio billing objects into your warehouse on a schedule with zero maintenance.

Notes

• Land raw tables first, then build clean models on top.
• Amounts are often in cents — divide in a model layer.
• Keep metered/usage components separate from recurring MRR.
• Use revenue schedules (not billings) for recognized/deferred revenue.

Can you generate a Maxio dashboard with AI?

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

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

Create a polished Metabase dashboard for Maxio subscription and SaaS-metric
analytics using the available Maxio tables in this database.

Goal: Help finance and RevOps leaders understand recurring revenue (MRR/ARR),
churn, retention, billings, and usage/component revenue from Maxio (Chargify +
SaaSOptics) data.

First, inspect the schema and identify the available Maxio tables. Do not assume
exact table names. Map the raw data into these analytical concepts where
possible: Customers, Subscriptions, Products/Price points, Components (metered /
add-on), Invoices, Transactions, and (if present) Revenue schedules.

Important:
- Build the dashboard from durable database/warehouse tables (Maxio APIs,
  exports, or a managed connector).
- Compute MRR from active recurring subscription revenue, normalizing to a
  monthly amount; keep metered/usage and one-time revenue separate.
- Separate voluntary churn from failed-payment (dunning) churn.
- For revenue recognition, use recognized/deferred schedules, not billings.
- Report in a single reporting currency.
- Do not claim Metabase connects natively to Maxio unless that is explicitly
  true in this environment.

Dashboard title: Maxio Revenue Overview

Sections:
1. Executive summary (KPI cards): MRR; ARR; Net new MRR; Gross revenue churn %;
   Net revenue retention; Accounts receivable.
2. MRR & ARR: MRR movement by month; ARR by product/price point; New vs. renewal.
3. Churn & retention: Logo vs. revenue churn; Gross vs. net retention; Renewal
   rate by cohort.
4. Billings, AR & dunning: Invoiced revenue; AR aging; Failed payments and
   recovery.
5. Usage & components: Metered usage; Component attach rate; Overage revenue.

Filters: Product, Price point, Component, Currency, Date range.

Before finalizing, create or recommend reusable Metabase models:
modeled_maxio_subscriptions, modeled_maxio_components, modeled_maxio_invoices,
and modeled_maxio_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
Maxio. Keep it practical, dense, and executive-readable. Avoid vanity metrics.

How should you model Maxio data in Metabase?

Core tables

Modeling advice

• Build a modeled_maxio_mrr table from active recurring subscription revenue, excluding metered/usage.
• Define subscription state once (trialing/active/past_due/canceled).
• Keep component usage in its own model for usage-revenue analysis.
• Separate voluntary cancellations from failed-payment churn.
• Reconcile modeled MRR and AR against Maxio before trusting the numbers.

Which Maxio metrics should you track in Metabase?

What SQL powers Maxio dashboards in Metabase?

These assume the modeled tables above (PostgreSQL dialect). Adjust identifiers to match your schema.

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

SELECT
  date_trunc('month', canceled_at)                    AS month,
  COUNT(*)                                            AS churned_subscriptions,
  ROUND(SUM(mrr_at_cancel), 2)                        AS churned_mrr
FROM subscriptions
WHERE state = 'canceled'
  AND canceled_at >= CURRENT_DATE - INTERVAL '12 months'
GROUP BY 1
ORDER BY 1;

-- Metered / add-on component revenue by month
SELECT
  date_trunc('month', period_ended_at) AS month,
  c.name                               AS component,
  ROUND(SUM(cu.amount) / 100.0, 2)     AS component_revenue
FROM component_usages cu
JOIN components c ON c.id = cu.component_id
GROUP BY 1, c.name
ORDER BY 1, component_revenue DESC;

What are common mistakes when analyzing Maxio in Metabase?

Related

Related analytics

Related metrics

Related integrations

FAQ