From BigQuery to Interactive Dashboard in a Single Conversation with Claude

You have millions of rows living in Google BigQuery. You know the answers are in there. But getting from raw data to a dashboard your team can actually use takes days — a ticket to the data team, a Jira backlog, a Looker developer, a design review. By the time the chart lands in front of you, the decision has already been made.

What if you could skip the entire queue? What if you could open Claude, ask a question in plain English, watch it query your BigQuery warehouse in real time, and then say “now build me an interactive dashboard from this” — and it just… did?

That is exactly what this guide covers. A complete, working pipeline that anyone with a Google Cloud project can set up in under 30 minutes — and that most companies with expensive BI subscriptions have never heard of.

The Architecture: Five Nodes, One Conversation

Before touching a terminal, it helps to understand what we are actually building. The full pipeline has five components that work together as a seamless chain:

That is the entire chain. Let us build it.

Prerequisites: What You Need Before Starting

This setup takes roughly 15–30 minutes if you have the prerequisites in order.

Step 1: Create a Secure Service Account for Claude

The first thing we need is a dedicated Google Cloud identity for Claude — a service account with the minimum permissions required and nothing more. This is a critical security step that most tutorials skip entirely.

1.1 Create the Service Account

1.2 Assign the Minimum Required Roles

Grant exactly these three roles — and no others. Starting read-only is a best practice you should not skip, especially when connecting any AI tool to production data.

1.3 Download the JSON Key File

Move the key file to a secure location and lock down the permissions:

# Move to a secure directory
mkdir -p ~/.credentials
mv ~/Downloads/your-key-file.json ~/.credentials/claude-bigquery.json

# Restrict file permissions (macOS / Linux)
chmod 600 ~/.credentials/claude-bigquery.json

Step 2: Configure the BigQuery MCP Server

The Model Context Protocol (MCP) is an open standard that lets Claude talk to external systems through a defined set of tools. The BigQuery MCP server exposes three core tools to Claude: list_tables, describe_table, and execute_query.

You have two options: a local MCP server (runs on your machine, more control) or the remote managed MCP server from Google (no installation, OAuth-based, currently in preview). For this guide we use the local approach — it works today without any waitlist.

2.1 Edit the Claude Desktop Configuration File

Open the Claude Desktop configuration file in a text editor:

# macOS
open ~/Library/Application\ Support/Claude/claude_desktop_config.json

# Windows
notepad %APPDATA%\Claude\claude_desktop_config.json

Add the following block inside mcpServers:

{
  "mcpServers": {
    "bigquery": {
      "command": "uvx",
      "args": ["mcp-server-bigquery"],
      "env": {
        "BIGQUERY_PROJECT": "your-gcp-project-id",
        "BIGQUERY_LOCATION": "US",
        "BIGQUERY_KEY_FILE": "/Users/yourname/.credentials/claude-bigquery.json"
      }
    }
  }
}

2.2 Restart Claude Desktop

Close Claude Desktop completely (quit, do not just minimize) and reopen it. On the new conversation screen, you should see a small hammer icon () in the input area — this confirms that Claude has detected and loaded the MCP server.

If the icon is not there, double-check your JSON config for syntax errors and ensure that uvx (or npx) is accessible in your terminal path.

Step 3: Verify the Connection with 3 Test Queries

With the MCP server running, open a new chat in Claude Desktop and run these three verification queries in order. They go from simple to complex and confirm that the full connection is working.

Step 4: The Master Prompt for Dashboard Generation

This is the step that no other tutorial covers. Most guides stop at “Claude can answer questions about your data.” What we are doing here is asking Claude to go further: take the data it just retrieved and build a complete interactive dashboard as a Claude Artifact.

The quality of the dashboard depends almost entirely on the quality of your prompt. Here is the prompt structure that consistently produces the best results:

You have access to my BigQuery data through the MCP connection.

STEP 1 — Data retrieval:
Query the [dataset.table_name] table and pull [metric_1], [metric_2], [metric_3]
for the last [time period], grouped by [dimension].
Also pull [secondary_table] for comparison if relevant.

STEP 2 — Dashboard generation:
Using the data you just retrieved, build a complete interactive dashboard as a React Artifact with:
- A header with the dashboard title and last-updated date
- KPI summary cards at the top showing: [KPI_1], [KPI_2], [KPI_3]
- A [bar/line/area] chart showing [primary metric] over time
- A [pie/donut/table] showing breakdown by [dimension]
- A filter bar that lets me filter by [field_1] and [field_2]
- Clean, professional design with a [light/dark] color scheme

AUDIENCE: [your boss / clients / the product team]
PURPOSE: [weekly review / board presentation / client report]

Step 5: Publish and Share Your Dashboard

Once your dashboard is rendered in the Artifact panel, publishing it is a single click. In the top-right corner of the Artifact panel, click the Publish button. Claude generates a public URL that opens the exact same interactive dashboard in a clean browser view — no login required for viewers.

You can share this link in:

• Slack — Drop it in the team channel for async review
• Meeting presentations — Open it full-screen instead of a static slide
• Client reports — A live, interactive dashboard looks far more professional than a PDF export
• Notion or Confluence — Embed the URL as an iframe in your documentation

Real-World Use Cases by Team and Industry

The setup is generic — the use cases are anything but. Here are concrete examples of how different teams are using this pipeline today.

BigQuery + Claude vs Traditional BI Tools: An Honest Comparison

Let us address the obvious question: why would you use Claude for dashboards when tools like Looker, Tableau, or Power BI already exist? Here is an honest comparison based on real-world usage.

The honest take: Claude is not replacing Looker for a 500-person enterprise with a dedicated data team and compliance requirements. It is, however, a genuine replacement for small to mid-sized teams that are paying $3,000 a month for a tool they use to answer the same ten questions every week.

The “Live Dashboard” vs the “Dead Dashboard”

There is a concept worth naming explicitly. Traditional BI dashboards are dead by design — they answer the questions the builder anticipated when they built them, and nothing more. Want to slice by a different dimension? That is a new report request.

The Claude pipeline produces something fundamentally different: a live conversation around your data. After Claude generates your initial dashboard, you can immediately continue:

• “Break the revenue chart down by device type.”
• “Remove the table and add a geographic map instead.”
• “Add a benchmark line showing last year’s numbers.”
• “What does this trend mean? What might be driving the drop in week 8?”

Each of these instructions updates the Artifact in real time. The dashboard evolves with the conversation. That is qualitatively different from anything a static BI tool offers.

Security: What You Must Get Right

Connecting an AI tool to a production data warehouse is not something to do carelessly. Here are the non-negotiable security practices for this setup:

• Principle of least privilege — always: The service account should only have the three roles listed in Step 1. Use dataset-level IAM to restrict access to only the tables relevant to your use case.
• Never expose credentials in version control: Your JSON key file should never be committed to a Git repository. Add .credentials/ to your .gitignore immediately. Consider using GCP Workload Identity Federation for production setups.
• Disable dangerous SQL operations: If your MCP server implementation supports it, explicitly allow only SELECT and block INSERT, UPDATE, DELETE, DROP, and ALTER. Claude should only read — never write.
• Audit query logs: Every query Claude runs through MCP is logged in BigQuery’s INFORMATION_SCHEMA. Periodically review JOBS_BY_PROJECT to audit what has been queried and catch any unexpected behavior.

Audit query to review Claude’s activity:

-- Audit recent queries made through Claude's service account
SELECT
  job_id,
  creation_time,
  user_email,
  query,
  total_bytes_processed,
  state
FROM `region-us`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE user_email = 'claude-bigquery-readonly@your-project.iam.gserviceaccount.com'
  AND creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
ORDER BY creation_time DESC
LIMIT 50;

Next Steps: Where to Take This Further

Conclusion: The Analyst That Never Sleeps

The shift happening here is more significant than it might appear. For the last decade, the bottleneck in data-driven organizations has not been the data — it has been the translation layer between the data and the people who need it. SQL, LookML, DAX, data modeling — these are hard enough to create a structural dependency on a specialized role.

What BigQuery + Claude + MCP does is collapse that translation layer entirely. The person with the question is now the person who gets the answer — directly, in seconds, with a shareable visual artifact that they built themselves in plain English.

That is not a small improvement in tooling. It is a rethinking of who gets to be a data analyst.

Further Reading & Resources

• Integrating BigQuery with Anthropic’s Claude — Google Cloud Blog (Sep 2024)
• Using the Fully Managed Remote BigQuery MCP Server — Google Cloud Blog (Jan 2026)
• Official BigQuery MCP Server Documentation — Google Cloud
• Connect LLMs to BigQuery with MCP Toolbox — Google Cloud Docs
• mcp-server-bigquery — Open Source MCP Server (GitHub)
• Configuring MCP to Automate Data Analysis: The DevOps Way — Medium