How to build Crisp chat dashboards in Metabase

Crisp is a live-chat and messaging platform with a shared inbox, chatbot, and the Hugo 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 Crisp 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 Crisp to Metabase?

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

• Conversation volume — opened vs. resolved by day and hour
• Time to first response — critical for live chat
• Missed and abandoned chats — where you're losing visitors
• Backlog and aging — unresolved conversations and how long they wait
• Operator performance — workload, handle time, and concurrency
• Segments and drivers — volume by topic, page, or trigger
• Visitors — new vs. returning

Which Crisp dashboards should you build in Metabase?

How do you build the Crisp → Metabase pipeline?

Every pipeline is the same four stages: extract from Crisp's API, load into a database, model the raw tables into clean ones, and visualize in Metabase. You can assemble this with a managed connector or a free script you host yourself.

Connector options

• dlt (free, code) — write a Python pipeline against the Crisp REST API; the most reliable route since there's no first-party managed connector.
• Crisp REST API (free, raw) — the source of truth; paginate conversations and messages and upsert on a schedule.
• Webhooks (free) — subscribe to Crisp's real-time events to keep your warehouse fresh.

Notes

• Land raw tables first, then build clean models on top.
• Crisp timestamps are epoch milliseconds — convert with to_timestamp(ms / 1000) in your model layer.
• Sync messages so you can compute response time, not just conversation counts.

Can you generate a Crisp dashboard with AI?

Yes — and once Crisp 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 Crisp Chat Overview dashboard

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

Create a polished Metabase dashboard for Crisp live-chat support analytics using
the available Crisp tables in this database.

Goal: Help support leaders understand chat volume, responsiveness, resolution, and
contact drivers from Crisp data.

First, inspect the schema and identify the available Crisp tables. Do not assume
exact table names. Map the available raw tables into these analytical concepts
where possible: Conversations, Messages, People (contacts), Operators (agents),
Segments, and Sessions.

Important:
- Build the dashboard from durable database/warehouse tables.
- Use medians (p50) and p90 for response times, never averages.
- Define "first response" as the first outbound operator message, excluding
  automated/bot messages and internal notes.
- Chat is concurrent and fast — measure response in minutes, and consider missed
  chats explicitly.
- If conversation state history is missing, do not calculate time-in-state. Use a
  caveat instead.
- Do not claim Metabase connects natively to Crisp unless that is explicitly true
  in this environment.

Dashboard title: Crisp Chat Overview

Sections:
1. Executive summary (KPI cards): Conversations opened last 7 days; Resolved last
   7 days; Open backlog; Median time to first response; Volume by hour.
2. Volume & backlog: Opened vs resolved by day; Open by state; Aging unresolved;
   Volume by hour.
3. Response time: First response p50/p90 by week; Missed chats by day; Reopened by
   week (only if history exists).
4. Operator performance: Resolved by operator; Open assigned by operator; Median
   handle time by operator; Concurrent chats.
5. Segments & drivers: Volume by segment; Volume by page/trigger; New vs returning
   visitors; CSAT by week (only if ratings exist).

Filters: Operator, Segment, State, Date range.

Before finalizing, create or recommend reusable Metabase models:
modeled_crisp_conversations, modeled_crisp_messages, modeled_crisp_people, and
modeled_crisp_operators.

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 Crisp data in Metabase?

Core tables

Modeling advice

• Convert epoch-millisecond timestamps once in a model so dates and durations are right.
• Define first response from the first non-automated operator message.
• Normalize state (pending/unresolved/resolved) so charts stay stable.
• Treat segments as a bridge so a conversation can carry many topics.
• Define "resolved" once and reuse it everywhere.

Which Crisp metrics should you track in Metabase?

What SQL powers Crisp dashboards in Metabase?

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

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

WITH first_outbound AS (
  SELECT
    m.conversation_id,
    MIN(m.created_at) AS first_reply_at
  FROM messages m
  WHERE m.from = 'operator'
    AND m.is_automated = false
  GROUP BY m.conversation_id
)
SELECT
  date_trunc('week', to_timestamp(c.created_at / 1000)) AS week,
  percentile_cont(0.5) WITHIN GROUP (
    ORDER BY (f.first_reply_at - c.created_at) / 60000.0
  ) AS median_first_reply_min
FROM conversations c
JOIN first_outbound f ON f.conversation_id = c.session_id
GROUP BY 1
ORDER BY 1;

SELECT
  c.state,
  COUNT(*)           AS conversations
FROM conversations c
WHERE c.state <> 'resolved'
GROUP BY c.state
ORDER BY conversations DESC;

SELECT
  EXTRACT(HOUR FROM to_timestamp(c.created_at / 1000)) AS hour_of_day,
  COUNT(*)                                              AS conversations
FROM conversations c
WHERE to_timestamp(c.created_at / 1000) >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY 1
ORDER BY 1;

What are common mistakes when analyzing Crisp in Metabase?

Related

Related analytics

Related integrations

FAQ