How to build Clay enrichment dashboards in Metabase

{
  "mcpServers": {
    "clay": {
      "command": "npx",
      "args": ["-y", "@clay-inc/mcp-server"],
      "env": { "CLAY_API_KEY": "your-clay-api-key" }
    }
  }
}

# Install the Metabase CLI
npm install -g @metabase/cli

# Log in (opens your browser; requires Metabase v62+)
mb auth login --url https://your-metabase.example.com

# Load a Clay CSV export — creates a table AND a model
mb upload csv --file clay-records.csv --collection root

# Refresh that same table later from a new export
mb upload replace <table-id> --file clay-records.csv

Create a polished Metabase dashboard for Clay enrichment analytics.
Work end to end: get the data into Metabase if it isn't there yet, then build.

Goal: Help RevOps and data teams understand enrichment coverage, provider
performance, credit usage, and list quality from Clay data.

Step 1 — Find or load the data:
- First, check what already exists in Metabase (search for Clay tables and
  models). If durable Clay data is already present — exported from a warehouse or
  uploaded earlier — use it and skip to Step 2.
- If nothing is there, pull it with the Clay MCP server: table records,
  enrichment results (with the provider that resolved each field), credit/usage
  events, and verification results. Write each result to a CSV, then load it with
  the Metabase CLI — run "mb upload csv --file <export>.csv" so each upload
  creates a table and a ready-to-query model. Use "mb upload replace <table-id>
  --file <export>.csv" to refresh an existing table instead of creating
  duplicates.

Step 2 — Inspect before querying:
Clay CSV exports are usually flat and pre-aggregated (one row per record, with
enrichment columns and a resolving provider). Warehouse tables are rawer, often
with a separate row per field attempt. Inspect the actual tables and column
names first; do not assume exact names or that a per-attempt table exists.

Important:
- Build on whatever data is present; don't claim Metabase connects natively to
  Clay — it reads a database or CLI-uploaded tables.
- Define enrichment "coverage" as the share of records with a non-null value in a
  field, and "match/hit rate" as resolved attempts ÷ attempts — keep them
  distinct.
- Attribute a resolved field to the provider that resolved it (waterfall) so
  provider hit rate is meaningful.
- Report credits and cost with their denominators (per record, per usable
  contact) visible.
- Only build a card if its underlying column/metric exists in the data.
- A single CSV is a point-in-time snapshot: only build trend cards if there is a
  usable date column or multiple periods have been uploaded.

Dashboard title: Clay Enrichment Overview

Sections:
1. Executive summary (KPI cards): Records enriched; Coverage (key fields);
   Provider hit rate; Credits used; Cost per enriched record; Verified email
   share.
2. Coverage: By column; fully vs. partially enriched; by source table.
3. Providers: Hit rate by provider; first vs. fallback; cost per resolved field.
4. Credits & cost: Credits by table and week; cost per record; wasted credits.
5. List quality: Verified vs. risky; duplicates vs. CRM; ICP fit.

Filters: Table, Provider, Column, Date range.

Reuse the models Metabase auto-created from uploaded CSVs, or (for a warehouse)
create reusable models: modeled_clay_records, modeled_clay_enrichment_results,
modeled_clay_credit_events, and modeled_clay_verifications.

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 data. Reconcile totals against
Clay's own usage views. Keep it practical, dense, and executive-readable.

Share of records with an email, phone, and LinkedIn, by source table.

-- Enrichment coverage by field, by source table
SELECT
  r.source_table,
  COUNT(*)                                            AS records,
  ROUND(100.0 * COUNT(r.email) / COUNT(*), 1)         AS pct_with_email,
  ROUND(100.0 * COUNT(r.phone) / COUNT(*), 1)         AS pct_with_phone,
  ROUND(100.0 * COUNT(r.linkedin_url) / COUNT(*), 1)  AS pct_with_linkedin
FROM modeled_clay_records r
GROUP BY r.source_table
ORDER BY records DESC;

Resolved attempts as a share of attempts, by provider.

-- Hit rate by enrichment provider
SELECT
  e.provider,
  COUNT(*)                                              AS attempts,
  COUNT(*) FILTER (WHERE e.resolved)                    AS resolved,
  ROUND(100.0 * COUNT(*) FILTER (WHERE e.resolved)
    / NULLIF(COUNT(*), 0), 1)                           AS hit_rate_pct
FROM modeled_clay_enrichment_results e
GROUP BY e.provider
ORDER BY attempts DESC;

Cost efficiency by week, using valid emails as the usable base.

-- Cost efficiency: credits per usable contact by week
SELECT
  date_trunc('week', c.used_at) AS week,
  SUM(c.credits)                AS credits_used,
  COUNT(DISTINCT r.id) FILTER (WHERE r.email IS NOT NULL AND r.email_status = 'valid') AS usable_contacts,
  ROUND(SUM(c.credits)::numeric
    / NULLIF(COUNT(DISTINCT r.id) FILTER (WHERE r.email IS NOT NULL AND r.email_status = 'valid'), 0), 2)
    AS credits_per_usable_contact
FROM modeled_clay_credit_events c
LEFT JOIN modeled_clay_records r ON r.id = c.record_id
GROUP BY 1
ORDER BY 1;