Analyze GA4 with AI: MCP Setup for Claude & Cursor (and Where ChatGPT Fits).

Ask ChatGPT to open your GA4 dashboard and, until recently, that was the end of the conversation — a chat window has no idea your Google Analytics property exists. Google closed part of that gap first: its own official, experimental Google Analytics MCP server has been public since July 2025 — about a year before this piece. NiceLookingData added a different kind of connection on July 2, 2026: an MCP server over audit findings, not raw GA4 reports. Both let an AI assistant read analytics data mid-conversation, but they do it in genuinely different ways, and the difference matters more than the headline "AI can see your GA4 data now."

This is a landscape overview, not a pitch for one tool. It covers what MCP actually is, what connecting your analytics to Claude, ChatGPT, or Cursor really buys you, who else is building this, how to set up our server if you decide you want it, and — the part most setup guides skip — where an LLM genuinely gets your data wrong if you hand it the wrong shape of information.

What MCP Actually Is

Model Context Protocol (MCP) is an open standard — released by Anthropic in late 2024, now adopted well beyond Claude — for connecting an AI assistant to external tools and data sources through one common interface instead of a bespoke integration per app. An "MCP server" is a small program that exposes a fixed list of named tools (get_latest_audit, run_report, whatever the server's author decided to build) along with a plain-English description of what each one does and what arguments it takes.

Your AI client — Claude Desktop, Cursor, ChatGPT — reads that list, decides mid-conversation which tool answers your question, calls it, and reads the structured result back into the chat. You don't write integration code and you don't memorize an API. You point the client at the server once (typically one JSON config block or a one-click install), and the assistant decides when to use it based on what you actually ask.

What Connecting Your Analytics to an AI Assistant Actually Buys You

Past the novelty, there are three concrete things an MCP connection changes about how you work with analytics data:

• Ask instead of navigate. "Which of my properties needs attention right now" or "did my GTM score improve since last week" gets answered in a sentence, instead of opening a report, picking a date range, and reading a table yourself.
• It stays inside the tool you're already in. A developer in Cursor fixing a tracking bug can ask what the last audit flagged on that page without alt-tabbing to a dashboard. That's the actual point of MCP over a regular web app — the assistant meets you where you're working.
• Summarization on demand. "Summarize what's critical across all my properties" turns a portfolio of separate reports into one answer, which matters more the more properties or containers you're responsible for.

None of this replaces GA4's own interface for deep, open-ended exploration — an MCP server answers the questions its tools were built to answer, nothing more. What it removes is the friction of opening a dashboard for a question you could ask in one sentence.

The GA4 + AI Landscape, July 2026

As of this writing, there are three distinct lanes for connecting GA4 to an AI assistant, and they are not interchangeable — they expose different data, in different shapes, with different setup costs.

Google's Own (Experimental) GA4 MCP Server

Google publishes an official Google Analytics MCP server — labeled "Experimental" in the README's own title, live and maintained since mid-2025. It runs locally on your machine (installed via pipx, Python 3.10+), authenticates with your own Google Application Default Credentials (gcloud auth application-default login, requesting the analytics.readonly scope alongside a broader cloud-platform scope Google's own setup docs pair it with for ADC quota-project billing), and Google documents wiring it into Gemini CLI, Gemini Code Assist, or Claude Code.

What it exposes is genuine ad hoc reporting: tools like run_report, run_realtime_report, and run_funnel_report, plus account and property metadata lookups. That means you can genuinely ask "what were my top-selling products yesterday" and get a live answer built from a report the model constructs on the fly — something no audit-findings tool, including ours, does. Google is explicit that it's read-only: it can query, not edit, your configuration.

Community & Self-Hosted GA4 MCP Servers

There is also a long tail of independently maintained GA4 MCP servers on GitHub, built by individual developers and small teams, mostly wrapping the same GA4 Data API Google's own server uses. Quality, maintenance, and security practice vary enormously — some are one person's weekend project, some are actively maintained with real test coverage. Because you typically run these yourself and hand them your own GA4 credentials (an OAuth client or a service account you provision), the responsibility for reading the code before trusting it with read access to your analytics sits entirely with you. That's not a knock on the category — open source thrives on exactly this kind of experimentation — it's just a genuinely different trust model than installing something from Google or paying for a hosted service.

Audit-Layer MCP Servers (Where NiceLookingData Fits)

Our server is a different shape of tool entirely. It doesn't expose the GA4 Data API or let a model construct arbitrary reports — it exposes GA4, GTM, and URL audit results that already exist — pre-scored, pre-prioritized, run against a fixed set of checks (61 for GA4, 44 for GTM, 37 for URL audits) — plus a natural-language tool that answers questions about your audit portfolio. It's hosted, not local, and authenticates with a single API key instead of a Google OAuth or service-account credential. The trade-off is the mirror image of Google's server: less open-ended, more structured; nothing to install, but nothing you can ask that isn't already covered by an audit check either.

Connecting NiceLookingData's MCP Server

Step 1: Generate an API key. In Settings → API & integrations, generate a key. The plaintext value is shown once at creation and can't be retrieved again — copy it somewhere safe immediately. One active key per account; regenerating replaces it instantly, and anything using the old key starts getting 401s.

Step 2: Add the server to your client's MCP config. The endpoint is https://www.nicelookingdata.com/api/mcp (Streamable HTTP transport), authenticated with the same key as a standard bearer token. The same JSON block works for Claude Desktop, Claude Code, and Cursor's mcp.json — all three read this shape natively:

{
  "mcpServers": {
    "nicelookingdata": {
      "url": "https://www.nicelookingdata.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Step 3: Ask it something. Once the client picks up the server (Claude Desktop and Cursor both show connected servers with their available tools in the UI), try "what's my latest GA4 audit score" or "which of my properties has the most critical findings right now."

Step 4: Rotate or revoke anytime. Same Settings tab, same key — this applies to both the MCP server and the REST endpoint together, since they share authentication.

Four tools are exposed. get_latest_audit returns your most recent audit's property, audit type, score, and severity counts — no arguments needed. list_recent_audits lists up to 20 recent audits across every property, most recent first. get_audit_findings takes an audit id (from either of the tools above) and returns the per-check findings for that specific audit — GA4, GTM, and URL audits all come back in the same section/check shape, so the model isn't reasoning about three different data formats depending on what you ran. And ask_analyst takes a free-form question and answers it using your recent audit summaries — the same AI analyst behind the dashboard's Ask Anything feature.

One deliberate design choice worth knowing about: get_audit_findings caps its response at 100 checks total and trims each finding to a few hundred characters. It's not hiding anything — a full GA4 audit already returns well under that cap — it's a token-budget decision. A model reasoning over a capped, consistently-shaped JSON payload answers better than one skimming a much larger raw dump, which is exactly the theme of the limitations section below. A response looks roughly like this (example values, not a real account):

{
  "propertyName": "example.com — Production",
  "auditType": "ga4",
  "overallScore": 74,
  "timestamp": "2026-07-08T09:14:00.000Z",
  "checkSummary": { "critical": 3, "warning": 9, "ok": 49 }
}

Rate limit and tier gate are identical to the REST API: 60 requests per minute per key, Agency plan required. If you don't have an Agency key but want the underlying findings, the audits themselves are available to every tier through the regular GA4 auditor — MCP is a different door onto the same data, not a different audit.

A Note for ChatGPT Users Specifically

The title of this piece promises Claude, ChatGPT, and Cursor, so it's worth being precise about where ChatGPT actually stands today. ChatGPT's Developer Mode (available on Plus, Pro, Business, Enterprise, and Edu plans) lets you add a remote MCP server as a connector — but its connector auth model is built around a full OAuth 2.1 flow, or no auth at all. As of this writing, there isn't a field in ChatGPT's Add Connector UI where you paste a static bearer API key the way you would into Claude Desktop's config or Cursor's mcp.json. Servers built around a simple issued API key — ours included, and most self-hosted community GA4 servers too — are consequently Claude- and Cursor-ready today, with ChatGPT support gated on either the connector UI accepting bearer keys directly or the server standing up its own OAuth provider.

This isn't a permanent wall — MCP support across every client is moving fast, and it's entirely plausible this paragraph is out of date within a few months of publishing. If you're building your own integration in the meantime, the plain REST endpoint (GET /api/v1/audits/latest, same API key, same rate limit) works with anything that can make an authenticated HTTP call, MCP client or not.

What You Can Actually Ask It

Grounded in what the four tools actually do, not a wish list:

• "What's my latest GA4 score, and what's critical right now?"
• "List my last five audits — which property is trending down?"
• "Pull the findings for audit [id] and summarize the top 3 fixes."
• "Across my whole portfolio, where should I start this week?"

What it can't do is answer anything outside those four tools' scope — "what was my bounce rate on the pricing page last Tuesday" isn't a question any of them were built to answer, because that's live report data, not an audit finding. That's exactly the gap Google's own server (or a raw Data API server) fills instead. Knowing which lane a question belongs to is most of what makes an MCP-connected assistant actually useful rather than a source of confidently wrong answers.

The Realistic Limits

Every setup guide for this covers the happy path. Here's what tends to go unmentioned.

LLMs misread raw data without structure

Hand a model raw GA4 API output — arrays of dimension/metric rows, non-additive metrics like "users" spread across date buckets, a report it had to construct the query for itself — and it has to guess at semantics the same way a human analyst would, except silently and without flagging uncertainty. A model can sum a metric that shouldn't be summed across dates, pick the wrong default date range, or misread which column is a rate versus a count, and hand back a confident, wrong number. This is a documented failure mode of LLMs over unstructured or semi-structured numeric data, not a defect specific to any one server. Pre-scored, fixed-shape data — a severity, a check title, a one-paragraph finding — removes that failure class because there's no ambiguous aggregation for the model to get wrong. The trade-off, covered above, is that you can only ask what the fixed tool set supports.

Read-only access is not a minor detail

Both Google's official server and ours are explicitly read-only — an MCP connection can surface your data but can't touch your GA4 configuration or your GTM container. That's worth actually checking before connecting any server, the same way you'd check what OAuth scopes a GTM automation tool requests. An MCP server that can write is a materially bigger blast radius than one that can only read, particularly for a connection an AI assistant is deciding when to invoke on its own.

Token costs are real, and raw data volume is the wrong direction for MCP

Pulling row-level GA4 data into a model's context window — weeks of events, hundreds of report rows — burns tokens fast, and most context windows aren't built for that kind of volume. Either the data gets sampled or truncated before it reaches the model (losing fidelity) or the request gets expensive fast. This is exactly why get_audit_findings caps and trims its output rather than dumping everything: a pre-aggregated summary is cheap in tokens; raw exploration at any real data volume belongs in GA4's BigQuery export and SQL — see our full BigQuery export guide — not stuffed into a chat context one report at a time.

The assistant only knows what its tools expose

This sounds obvious written down and still catches people in practice: an MCP-connected assistant isn't reasoning over your actual GA4 property, it's reasoning over whatever a specific tool call returned. Ask it something adjacent to what a tool supports and it can extrapolate plausibly — and be wrong. ask_analyst is also stateless per call on our server — it doesn't remember what you asked five minutes earlier in the same chat, so a follow-up question needs its own full context, not "and what about the other one." Neither of these is a defect so much as a property of how tool-calling works that's worth knowing before you trust an answer at face value.

FAQ

What is MCP (Model Context Protocol)?

An open standard, released by Anthropic in late 2024, that lets an AI assistant call external tools through one common interface. An MCP server exposes a fixed list of named tools; your AI client calls them mid-conversation when your question matches what a tool does, instead of you writing integration code yourself.

Can I connect Google Analytics 4 to Claude?

Yes, and it's the most mature client for this today. Both Google's official GA4 MCP server and NiceLookingData's server document Claude Desktop and Claude Code setup — paste a JSON config block once and the assistant can call the server's tools in any chat.

Can I connect Google Analytics 4 to ChatGPT?

Partially, and it depends on the server. ChatGPT's Developer Mode supports MCP connectors, but its auth model expects OAuth or no auth — not a pasted static API key. Servers built around a simple issued key, including ours and most self-hosted GA4 servers, aren't a direct fit for ChatGPT's connector UI as of this writing, even though they work natively in Claude and Cursor.

Does Google have an official GA4 MCP server?

Yes — googleanalytics/google-analytics-mcp, labeled experimental. It runs locally, authenticates with your own Google credentials, and exposes genuine ad hoc reporting tools (run_report, run_realtime_report, run_funnel_report, account and property lookups) — read-only, documented for Gemini CLI, Gemini Code Assist, and Claude Code.

Is it safe to connect an AI assistant to my analytics data?

Check what the server can actually authorize before connecting it — the same discipline as checking GTM edit scopes. Both Google's official server and NiceLookingData's are explicitly read-only: they can surface data but can't change your GA4 or GTM configuration. A server that requests write access is a meaningfully bigger risk, especially for a tool an AI assistant decides on its own when to call.

Do I need to know how to code to set this up?

No coding, but the setup differs by server. Google's official server needs a one-time local install (Python, pipx, a Google login command) before it'll run. NiceLookingData's server needs zero local install — generate a key in Settings and paste one JSON block into your client's MCP config.

Is NiceLookingData's MCP server free?

No — it ships on the Agency plan, the same entitlement as our REST API. The GA4, GTM, and URL audits it reads from are available on every tier through the dashboard; MCP is a different way to reach that same data, gated separately.