How to build Intercom support dashboards in Metabase

Intercom is where your team has conversations with customers across chat, email, and social, increasingly with the Fin AI agent. Metabase is where you turn that activity into shared, trustworthy dashboards. Because Metabase reads from SQL databases, the reliable way to connect them is a small pipeline: sync Intercom 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 Intercom to Metabase?

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

• Conversation volume — opened vs. closed by day, channel, and team
• Time to first response — how long customers wait for a reply
• Time to close — opened to closed, with median and p90
• Fin AI resolution — how much the AI agent resolves vs. hands over
• Backlog and aging — open conversations and how long they wait
• CSAT — conversation ratings over time
• Teammate and team load — workload distribution and handle time

Which Intercom dashboards should you build in Metabase?

How do you build the Intercom → Metabase pipeline?

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

Connector options

• dlt (free, code) — write a Python pipeline against the Intercom REST API for full control. The lightest path to a maintainable, no-vendor sync.
• Intercom REST API (free, raw) — the source of truth; paginate conversations and use the Data Export for bulk history.
• Airbyte — has an Intercom source covering conversations, contacts, admins, companies, tags, and segments. Free if you self-host the open-source version; paid on Airbyte Cloud.
• Fivetran (paid, managed) — offers an Intercom connector with a maintained schema and incremental syncs.

Notes

• Land raw tables first, then build clean models on top.
• Intercom timestamps are Unix epochs — convert with to_timestamp() in your model layer.
• Capture conversation state changes if you want accurate time-in-state and reopen analysis.

Can you generate an Intercom dashboard with AI?

Yes — and once Intercom 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 Intercom Support Overview dashboard

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

Create a polished Metabase dashboard for Intercom support analytics using the
available Intercom tables in this database.

Goal: Help support and CX leaders understand conversation volume, response time,
Fin AI resolution, CSAT, and teammate workload from Intercom data.

First, inspect the schema and identify the available Intercom tables. Do not assume
exact table names. Map the available raw tables into these analytical concepts
where possible: Conversations, Conversation parts (messages), Contacts, Admins
(teammates), Teams, Tags, Segments, Companies, and conversation statistics if
available.

Important:
- Build the dashboard from durable database/warehouse tables.
- Use medians (p50) and p90 for response and close times, never averages.
- Define "first response" as the first human teammate reply unless you are
  explicitly measuring Fin AI, in which case separate AI replies clearly.
- If conversation state-change history is missing, do not calculate time-in-state.
  Use a caveat instead.
- Do not claim Metabase connects natively to Intercom unless that is explicitly
  true in this environment.

Dashboard title: Intercom Support Overview

Sections:
1. Executive summary (KPI cards): Conversations opened last 7 days; Closed last 7
   days; Open backlog; Median time to first response; Median time to close;
   Fin resolution rate (only if AI resolution data exists).
2. Volume & backlog: Opened vs closed by day; Open by state; Backlog aging;
   Volume by channel.
3. Response time: First response time p50/p90 by week; Conversations over target
   by team; Time to close by week.
4. Fin AI & deflection: Fin resolution rate by week; AI vs human resolved;
   Handover rate; CSAT for AI vs human (only if rating data exists).
5. Teammate & team: Closed by teammate; Median handle time by team; Open assigned
   by teammate; Rating by team.

Filters: Team, Teammate, Channel, Tag, Segment, State, Date range.

Before finalizing, create or recommend reusable Metabase models:
modeled_intercom_conversations, modeled_intercom_conversation_parts,
modeled_intercom_contacts, modeled_intercom_admins, and
modeled_intercom_companies.

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. Keep it practical, dense,
and executive-readable. Avoid vanity metrics.

How should you model Intercom data in Metabase?

Core tables

Modeling advice

• Convert epoch timestamps once in a model layer so every question uses real dates.
• Use author_type on conversation parts to separate human, bot, and customer messages — essential for honest first-response and Fin metrics.
• Prefer Intercom's time_to_first_response / time_to_closewhen present rather than recomputing from parts.
• Treat tags as a bridge table so a conversation can carry many tags.
• Define "closed" once and reuse it everywhere.

Which Intercom metrics should you track in Metabase?

What SQL powers Intercom dashboards in Metabase?

These assume the modeled tables above (PostgreSQL dialect, epoch timestamps). Adjust identifiers to match your warehouse.

SELECT
  date_trunc('day', to_timestamp(c.created_at)) AS day,
  COUNT(*)                                       AS opened,
  COUNT(*) FILTER (WHERE c.state = 'closed')     AS closed
FROM conversations c
WHERE to_timestamp(c.created_at) >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY 1
ORDER BY 1;

SELECT
  date_trunc('week', to_timestamp(c.created_at)) AS week,
  percentile_cont(0.5) WITHIN GROUP (
    ORDER BY c.time_to_first_response / 60.0
  ) AS median_frt_min,
  percentile_cont(0.9) WITHIN GROUP (
    ORDER BY c.time_to_first_response / 60.0
  ) AS p90_frt_min
FROM conversations c
WHERE c.time_to_first_response IS NOT NULL
GROUP BY 1
ORDER BY 1;

SELECT
  date_trunc('week', to_timestamp(c.created_at)) AS week,
  COUNT(*)                                          AS total_closed,
  COUNT(*) FILTER (WHERE c.ai_agent_participated)   AS ai_handled,
  ROUND(
    100.0 * COUNT(*) FILTER (WHERE c.ai_agent_participated AND NOT c.handed_over)
      / NULLIF(COUNT(*), 0),
    1
  ) AS fin_resolution_pct
FROM conversations c
WHERE c.state = 'closed'
GROUP BY 1
ORDER BY 1;

SELECT
  t.name             AS team,
  COUNT(*)           AS open_conversations
FROM conversations c
LEFT JOIN teams t ON t.id = c.team_assignee_id
WHERE c.state = 'open'
GROUP BY t.name
ORDER BY open_conversations DESC;

What are common mistakes when analyzing Intercom in Metabase?

Related

Related analytics

Related integrations

FAQ