How to build Gorgias support dashboards in Metabase

Gorgias is the help desk built for ecommerce, tying customer tickets to orders from Shopify and other stores. 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 Gorgias 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 Gorgias to Metabase?

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

• Ticket volume — created vs. closed by day and channel
• First response time — especially during sales peaks
• Support-driven revenue — orders and conversions linked to support
• Return and refund drivers — top contact reasons by tag
• Backlog and aging — open work and how long it's been waiting
• CSAT — satisfaction surveys over time
• Repeat contacts — customers writing in again and again

Which Gorgias dashboards should you build in Metabase?

How do you build the Gorgias → Metabase pipeline?

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

Connector options

• dlt (free, code) — write a Python pipeline against the Gorgias REST API; the most reliable route since there's no first-party managed connector.
• Gorgias REST API (free, raw) — the source of truth; paginate tickets, messages, customers, and events and upsert on a schedule.
• Managed ETL (paid, verify) — check whether your ETL vendor offers a Gorgias connector; availability varies, so confirm before relying on it.
• Store data — sync your ecommerce platform (e.g. Shopify) alongside Gorgias so you can join tickets to orders.

Notes

• Land raw tables first, then build clean models on top.
• Capture ticket events if you want accurate reopen rate and time-in-status.
• Join on customer email or external order IDs to connect support with revenue.

Can you generate a Gorgias dashboard with AI?

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

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

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

Goal: Help ecommerce CX leaders understand volume, responsiveness, support-driven
revenue, CSAT, and contact drivers from Gorgias data.

First, inspect the schema and identify the available Gorgias tables. Do not assume
exact table names. Map the available raw tables into these analytical concepts
where possible: Tickets, Messages, Customers, Users (agents), Tags, Satisfaction
surveys, and any linked order/revenue data (e.g. Shopify) if present.

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 agent message, excluding internal
  notes and automated messages.
- Only build support-driven revenue cards if linked order data is actually present.
- If ticket event history is missing, do not calculate reopen rate or
  time-in-status. Use a caveat instead.
- Do not claim Metabase connects natively to Gorgias unless that is explicitly
  true in this environment.

Dashboard title: Gorgias Support Overview

Sections:
1. Executive summary (KPI cards): Tickets created last 7 days; Closed last 7 days;
   Open backlog; Median first response time; CSAT % (only if survey data exists);
   Support-influenced revenue (only if order data exists).
2. Volume & backlog: Created vs closed by day; Open by status; Backlog aging;
   Volume by channel.
3. Support-driven revenue: Tickets linked to orders; Top return drivers by tag;
   Conversion after support (only if order data exists).
4. Response time: First response p50/p90 by week; Volume by hour; Reopened by week.
5. CSAT & drivers: CSAT by week; Bad ratings by tag; Volume by tag; Repeat
   contacts.

Filters: Channel, Tag, Agent, Status, Date range.

Before finalizing, create or recommend reusable Metabase models:
modeled_gorgias_tickets, modeled_gorgias_messages, modeled_gorgias_customers,
modeled_gorgias_users, and modeled_gorgias_satisfaction.

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

Core tables

Modeling advice

• Define first response from the first from_agent = true, non-internal message.
• Normalize status (open/closed) and channel so charts stay stable.
• Join tickets to your store's orders on customer email or order reference to model support-driven revenue honestly.
• Treat tags as a bridge table so a ticket can carry many tags.
• Define "closed" once and reuse it everywhere.

Which Gorgias metrics should you track in Metabase?

What SQL powers Gorgias dashboards in Metabase?

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

SELECT
  date_trunc('day', t.created_datetime) AS day,
  COUNT(*)                                          AS created,
  COUNT(*) FILTER (WHERE t.status = 'closed')       AS closed
FROM tickets t
WHERE t.created_datetime >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY 1
ORDER BY 1;

WITH first_outbound AS (
  SELECT
    m.ticket_id,
    MIN(m.created_datetime) AS first_reply_at
  FROM messages m
  WHERE m.from_agent = true
    AND m.is_internal_note = false
  GROUP BY m.ticket_id
)
SELECT
  date_trunc('week', t.created_datetime) AS week,
  percentile_cont(0.5) WITHIN GROUP (
    ORDER BY EXTRACT(EPOCH FROM (f.first_reply_at - t.created_datetime)) / 60.0
  ) AS median_first_reply_min
FROM tickets t
JOIN first_outbound f ON f.ticket_id = t.id
GROUP BY 1
ORDER BY 1;

SELECT
  tg.name            AS tag,
  COUNT(*)           AS tickets
FROM tickets t
JOIN ticket_tags tt ON tt.ticket_id = t.id
JOIN tags tg ON tg.id = tt.tag_id
WHERE t.created_datetime >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY tg.name
ORDER BY tickets DESC
LIMIT 20;

SELECT
  c.email,
  COUNT(*)           AS ticket_count
FROM tickets t
JOIN customers c ON c.id = t.customer_id
WHERE t.created_datetime >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY c.email
HAVING COUNT(*) >= 3
ORDER BY ticket_count DESC
LIMIT 50;

What are common mistakes when analyzing Gorgias in Metabase?

Related

Related analytics

Related integrations

FAQ