Google Tag Manager MCP
Connect an AI app to Google Tag Manager and inspect or manage GTM configuration through OAuth, from read-only discovery to draft edits and deliberate publishing.
Check Google connection status, show setup instructions, save an OAuth client, start/finish login, and log out/revoke access.
List and get GTM accounts, containers, and workspaces.
Create new containers and draft workspaces.
List and inspect tags, triggers, and variables in a workspace.
Create tags, triggers, and variables in a draft workspace.
Update resources with full-replacement PUT semantics and fingerprint protection.
Delete tags, triggers, or variables.
List, enable, or disable built-in variables in a workspace.
Compile a workspace into an immutable container version, noting that the source workspace is deleted and replaced.
Publish a version, fetch a specific version, or inspect the currently live version.
Make raw Google Tag Manager API v2 requests for endpoints without dedicated tools.
Use OAuth scopes, rate limiting, retries, and read/write/destructive annotations to support safer, confirmation-aware workflows.
Provides tools to manage Google Tag Manager entities such as accounts, containers, workspaces, tags, triggers, variables, and versions, including compiling and publishing versions.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Google Tag Manager MCP Which tags fire on the page view trigger in container GTM-ABC123?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Google Tag Manager MCP
English | Русский
A1 Google Tag Manager MCP lets an AI app inspect and manage Google Tag Manager containers in plain language. See what fires on a page, work with tags, triggers and variables in a draft workspace, then deliberately compile and publish a version when you are ready.
It connects to the Google Tag Manager API v2 through your Google account. The difference from asking an AI to guess a GTM setup is that it works with the actual container, workspace and version you choose.
25 tools. 10 operations only read GTM data; 4 create drafts or change built-in variables; 5 can alter, delete, compile or publish live configuration.
Connects from the conversation. Say "connect Google Tag Manager": the server walks you through the OAuth client, catches Google's redirect on
127.0.0.1with PKCE and keeps the tokens itself — no config files, no restart.Draft first. Tags, triggers and variables are created in a workspace. Publishing is a separate, explicitly destructive operation.
Quota-aware. GTM permits 0.25 requests per second per project; the server spaces requests by at least 4.2 seconds instead of overwhelming the API.
Your Google access. The server uses your OAuth credentials and requests only the Tag Manager scopes needed for reading, editing, versioning and publishing.
Start with a read-only question:
Which tags in my containers fire on the page-view trigger?
Connect the server · Explore use cases · Open technical documentation
See it work in a minute
You: List my GTM containers and show which tags fire on page view.
Assistant: Lists the containers, their workspaces, relevant triggers and the tags attached to them. Nothing changes.
You: In the Default Workspace of
GTM-ABC123, prepare a GA4 configuration tag for measurement IDG-XXXXXXXon all pages.Assistant: Shows the workspace, proposed tag and trigger configuration, then asks for confirmation before creating the draft.
You: Confirm the draft.
Assistant: Creates the tag in the workspace. It does not publish the container; compiling and publishing a version remains a separate step.
Related MCP server: unboundai-gtm-mcp-server
Contents
Quick start
You need Node.js 20+ and a Google account. Credentials are not required at install time — the server connects from the conversation.
Add the server to your AI app.
Say "connect Google Tag Manager": the assistant walks you through creating the OAuth client and approving access without editing config files.
Start with the read-only question above.
In the app:
Open Settings → MCP servers.
Select Add server.
Choose STDIO, then enter
npx -y mcp-google-tagmanager@latestand the three environment variables below.
Variable | Value |
| Your Google OAuth client ID |
| Your Google OAuth client secret |
| Your Google OAuth refresh token |
Select Save, then Restart.
From the command line:
codex mcp add google-tagmanager \
-- npx -y mcp-google-tagmanager@latestcodex mcp listclaude mcp add \
--transport stdio \
--scope user \
google-tagmanager \
-- npx -y mcp-google-tagmanager@latestclaude mcp listThe current official path is Settings → Extensions. For a custom desktop extension, open Advanced settings → Extension Developer → Install Extension…, select a .mcpb file and follow the prompts.
This repository currently publishes an npm stdio package and does not contain a .mcpb bundle. For Claude Desktop builds that still support local configuration, use the following JSON stdio configuration as a fallback:
{
"mcpServers": {
"google-tagmanager": {
"command": "npx",
"args": ["-y", "mcp-google-tagmanager@latest"]
}
}
}In those builds, save it to ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows.
Claude Desktop MCP documentation
Add a user-level server to ~/.cursor/mcp.json on macOS/Linux or %USERPROFILE%\.cursor\mcp.json on Windows:
{
"mcpServers": {
"google-tagmanager": {
"type": "stdio",
"command": "npx",
"args": ["-y", "mcp-google-tagmanager@latest"]
}
}
}Run MCP: Open User Configuration from the Command Palette and add:
{
"servers": {
"google-tagmanager": {
"type": "stdio",
"command": "npx",
"args": ["-y", "mcp-google-tagmanager@latest"]
}
}
}Check it with MCP: List Servers.
What you can ask it to do
Understand the current setup
List the GTM accounts and containers I can access.
Which tags fire on page view in this workspace?
Show the trigger and variable configuration for this tag.
Which built-in variables are enabled?
Prepare tracking changes in a draft
Create a workspace for the checkout tracking change.
Prepare a GA4 tag and a trigger for a specific event.
Enable the click variables needed for this trigger.
Update this tag after showing me the complete replacement configuration.
Release a version deliberately
Compile this workspace into a version named
April release.Show the compiler errors, if any.
Publish version
42after I confirm the version and its changes.
How GTM changes are connected
GTM has a clear release path:
An account contains one or more containers.
A container has workspaces for draft changes.
Tags, triggers and variables belong to a workspace.
Compiling a workspace creates a container version and removes the source workspace. GTM provides a replacement workspace.
Publishing makes a selected container version live.
This server can inspect each step. It does not treat a draft as a release: version creation and publishing are separate operations.
What can change
Operation | What happens | Confirmation boundary |
List accounts, containers, workspaces, tags, triggers, variables and versions | Reads GTM configuration | No change |
Create a container or workspace | Adds a new GTM object | Changes GTM |
Create a tag, trigger or variable | Adds a draft object to a workspace | Changes a draft workspace |
Enable or disable built-in variables | Changes the workspace configuration | Changes a draft workspace |
Update a tag, trigger or variable | Replaces the complete resource, protected by its fingerprint | Potentially destructive |
Delete a tag, trigger or variable | Removes the selected object | Destructive |
Compile a workspace | Creates a version and deletes the source workspace | Destructive |
Publish a version | Makes a selected version live | Destructive |
Raw API request | Can call API methods without a dedicated tool | Potentially destructive |
The AI client decides how it asks for confirmation. The server marks read-only, write and destructive operations so the client can distinguish inspection from a real change.
Getting access
Google Tag Manager requires OAuth 2.0; an API key is not enough. There are two ways in, and the first one needs no configuration files.
Connect from the chat (recommended)
Say "connect Google Tag Manager" and the assistant runs the flow with you:
setup_instructionsprints the checklist: create or select a Google Cloud project, enable Tag Manager API, configure the consent screen and create a Desktop app OAuth client.Download that client's JSON ("Download JSON") and give the assistant its path —
set_clientstores it owner-only. The secret never goes through the conversation.start_loginreturns a Google consent link. Open it on this machine and approve; the code comes back to a one-shot listener on127.0.0.1(PKCE), never through the chat.finish_loginexchanges the code and saves the tokens to~/.config/mcp-google-tagmanager/credentials.json(mode 0600) and verifies them with a real Tag Manager API call — so an API that is still switched off is caught right there.
The tokens are re-read on every call, so the connection works immediately — no restart of the AI app. auth_status shows what is connected, logout revokes and deletes it.
Environment variables (CI, unattended installs)
Create or select a Google Cloud project and enable the Tag Manager API. A project without that API enabled receives no quota.
Configure the OAuth consent screen and create an OAuth client. A Desktop app client is suitable for local use.
Authorize your Google account and obtain a refresh token. The OAuth 2.0 Playground can do this if you enable Use your own OAuth credentials.
Request these scopes together:
https://www.googleapis.com/auth/tagmanager.readonly https://www.googleapis.com/auth/tagmanager.edit.containers https://www.googleapis.com/auth/tagmanager.edit.containerversions https://www.googleapis.com/auth/tagmanager.publish
The scopes are separate: reading, editing, compiling versions and publishing each need their corresponding permission. Treat the client secret and refresh token as passwords.
Configuration
Every variable is optional — with none of them the server connects from the chat.
Variable | Required | Description |
| No* | OAuth client ID. |
| No* | OAuth client secret. |
| No* | OAuth refresh token. |
| No* | Short-lived alternative to the OAuth trio. |
| No | Fixed loopback port for the in-chat login; useful over SSH port forwarding. |
| No | Tag Manager API base URL override. |
| No | Per-request timeout; default |
| No | Maximum retries on temporary failures; default |
| No | Minimum request spacing; default |
* Provide either the OAuth trio or an access token. Access tokens expire in about an hour and are not refreshed automatically.
Data and telemetry
The server runs locally and sends GTM API requests and OAuth refresh requests to Google. Its anonymous telemetry contains a random installation ID, package version, AI client and Node.js/operating-system versions, and tool names. It does not send OAuth tokens, GTM data, tool arguments or prompts. For each tool call it also sends the outcome and, on failure, an excerpt of the error text with e-mails, addresses, tokens, numbers of 4+ digits and quoted text replaced by #; a value from your request can appear in it if the error text contains it.
Disable telemetry for A1 MCP servers with:
ASKADS_TELEMETRY=0Limits and background work
GTM is rate-limited. The API allows 0.25 requests per second per project, so the server serializes calls at least 4.2 seconds apart. Broad audits can therefore take time.
Temporary limits are retried carefully.
429and Google quota403responses use exponential backoff andRetry-After. Reads retry after network and5xxfailures; writes are not replayed after an uncertain failure.There is no background monitoring. The server runs only when your AI app calls it. If the app supports scheduled tasks, it can periodically inspect a container or its live version.
A workspace disappears when compiled. Before calling
create_version, save anything you need from the workspace and inspect the returned replacement workspace path.
Technical documentation
MCP capability catalog — task-oriented pages for every tool.
Support
Found a bug or need a scenario? Create an issue or write in Telegram.
Available Tools
25 toolsauth_statusGoogle connection statusARead-onlyIdempotent
Shows whether this server is connected to Google: token presence and source (env variables or a stored in-chat login), expiry, the Google account email, granted vs missing OAuth scopes, where the credentials file lives and where the OAuth client comes from. Makes no network calls and never returns the token itself. Call it first when other tools report the server is not connected.
Inputs: no named parameters.
create_containerCreate a containerA
Creates a new container in a GTM account. usage_context declares the platform, e.g. ["web"]; other values include androidSdk5, iosSdk5, server. Returns the created Container with its server-assigned containerId and publicId. Requires the tagmanager.edit.containers scope.
Inputs: name (required), account_id (required), usage_context (required).
create_entityCreate a tag, trigger or variableA
Creates a tag, trigger or variable in a workspace. body is the resource JSON: minimally { name, type } plus type-specific parameter entries; tags also take firingTriggerId (array of trigger id strings). Example tag body: { "name": "GA4 event", "type": "gaawe", "parameter": [...], "firingTriggerId": ["12"] }. Returns the created resource with its server-assigned id and fingerprint. Requires the tagmanager.edit.containers scope.
Inputs: body (required), account_id (required), entity_type (required), container_id (required), +1 more.
create_versionCreate a container version from a workspaceADestructive
Compiles a workspace into an immutable Container Version (the unit that gets published). SIDE EFFECT: the source workspace is DELETED and replaced by a fresh one — the response's newWorkspacePath points to the replacement; use it for any further edits, or old workspace paths will 404. Returns { containerVersion (with containerVersionId and full tag/trigger/variable snapshots), syncStatus, newWorkspacePath }. A compile failure comes back as compilerError=true with HTTP 200 and is reported as an error. Requires the tagmanager.edit.containerversions scope (edit.containers is NOT sufficient).
Inputs: account_id (required), container_id (required), workspace_id (required), name, +1 more.
create_workspaceCreate a workspaceA
Creates a new workspace in a container — an isolated draft where tags, triggers and variables are edited before being compiled into a version. Returns the created Workspace with its server-assigned workspaceId. Requires the tagmanager.edit.containers scope.
Inputs: name (required), account_id (required), container_id (required), description.
delete_entityDelete a tag, trigger or variableADestructiveIdempotent
Deletes a tag, trigger or variable by its API path. The response is empty on success. Requires the tagmanager.edit.containers scope.
Inputs: path (required).
finish_loginFinish the Google loginAIdempotent
Second step: waits up to 20 s for the browser consent to finish, saves the tokens to an owner-only file and verifies the login with a read-only identity call, returning the account email and the granted scopes. After success every tool works immediately — no client restart. If the user granted only part of the requested permissions, the login is still saved and missingScopes lists what will not work. Logging in under a different Google account replaces the previous login (its refresh token is revoked best-effort) and the response carries previousAccountEmail so the change never goes unnoticed.
Inputs: no named parameters.
get_accountGet a GTM accountARead-onlyIdempotent
Gets one Google Tag Manager account by id. Returns the Account resource: { accountId, name, path, fingerprint, shareData }.
Inputs: account_id (required).
get_containerGet a containerARead-onlyIdempotent
Gets one container by account id + container id. Returns the Container resource including publicId (the GTM-XXXXXX snippet id), usageContext and fingerprint.
Inputs: account_id (required), container_id (required).
get_resourceGet any resource by pathARead-onlyIdempotent
Generic getter for any GTM resource by its API-relative path — tags, triggers, variables, versions, containers, workspaces. Prefer echoing the path field from a previous response over assembling the string yourself. Returns the full resource JSON including its current fingerprint (needed for update_entity).
Inputs: path (required).
get_workspaceGet a workspaceARead-onlyIdempotent
Gets one workspace by account id + container id + workspace id. Returns the Workspace resource with its fingerprint.
Inputs: account_id (required), container_id (required), workspace_id (required).
list_accountsList GTM accountsARead-onlyIdempotent
Lists all Google Tag Manager accounts the authorized user can access. Returns { account: [{ accountId, name, path, fingerprint }], nextPageToken }. All ids are strings. This is the entry point: every other tool needs an accountId (or a path) from here.
Inputs: page_token.
list_containersList containersARead-onlyIdempotent
Lists the containers of a GTM account. Returns { container: [{ containerId, name, publicId (e.g. GTM-XXXXXX), usageContext, path, fingerprint, tagManagerUrl }], nextPageToken }.
Inputs: account_id (required), page_token.
list_tagsList tagsARead-onlyIdempotent
Lists the tags of a workspace. Returns { tag: [{ tagId, name, type (e.g. html, gaawe), parameter: [{ type, key, value, list, map }], firingTriggerId, blockingTriggerId, paused, path, fingerprint, tagManagerUrl }], nextPageToken }.
Inputs: account_id (required), container_id (required), workspace_id (required), page_token.
list_triggersList triggersARead-onlyIdempotent
Lists the triggers of a workspace. Returns { trigger: [{ triggerId, name, type (e.g. pageview, click, customEvent), filter/customEventFilter (conditions of { type, parameter }), path, fingerprint }], nextPageToken }.
Inputs: account_id (required), container_id (required), workspace_id (required), page_token.
list_variablesList variablesARead-onlyIdempotent
Lists the user-defined variables of a workspace (built-in variables live in manage_built_in_variables). Returns { variable: [{ variableId, name, type (e.g. v = data layer, jsm = custom JS, c = constant), parameter, path, fingerprint }], nextPageToken }.
Inputs: account_id (required), container_id (required), workspace_id (required), page_token.
list_workspacesList workspacesARead-onlyIdempotent
Lists the workspaces of a container. Returns { workspace: [{ workspaceId, name, description, path, fingerprint }], nextPageToken }. Workspaces are mandatory in GTM v2: every tag/trigger/variable operation needs a workspaceId, and a "Default Workspace" always exists — call this first.
Inputs: account_id (required), container_id (required), page_token.
logoutDisconnect from GoogleADestructive
Revokes the stored token at Google (oauth2.googleapis.com/revoke) and deletes the local credentials file. Tokens supplied via env variables are NOT touched — remove them from the MCP client config manually; envTokenStillSet in the response says whether any are still in effect.
Inputs: no named parameters.
manage_built_in_variablesList/enable/disable built-in variablesAIdempotent
Manages a workspace's built-in variables (pageUrl, clickText, event, ...). These are toggles, not records: action "list" returns the currently enabled ones ({ builtInVariable: [...] }), "enable" and "disable" take types (BuiltInVariableType enum values) and switch them on/off. Enable/disable require the tagmanager.edit.containers scope.
Inputs: action (required), account_id (required), container_id (required), workspace_id (required), +1 more.
publish_versionPublish, inspect or fetch the live container versionADestructive
Container-version operations. action "publish" pushes a version live (replacing the currently published one; requires the tagmanager.publish scope; version_id required, fingerprint recommended). action "get" fetches one version by version_id. action "live" fetches the currently published version of the container (no version_id needed). Publish responses can carry compilerError=true with HTTP 200 — reported as an error. Returns the ContainerVersion (publish wraps it as { containerVersion, compilerError }).
Inputs: action (required), account_id (required), container_id (required), version_id, +1 more.
raw_requestRaw Tag Manager API callADestructive
Escape hatch to call any Google Tag Manager API v2 path directly, for endpoints without a dedicated tool (environments, folders, templates, zones, workspace :sync / :quick_preview, version_headers, ...). path is relative to /tagmanager/v2/, e.g. "accounts/1/containers/2/environments". query values may be arrays for repeated params. Requests go through the same OAuth, rate limiter and retries as every other tool.
Inputs: path (required), body, query, method.
set_clientSave the OAuth clientAIdempotent
Saves the OAuth client credentials from the JSON file downloaded from Google Cloud Console ('Download JSON' on a Desktop-app client). Pass the file PATH — the secret must never be pasted into the chat. The client is stored once in the shared ~/.config/mcp-google-auth/client.json (owner-only) and reused by every mcp-google-* server; tokens stay per-server. After this, call start_login.
Inputs: path (required).
setup_instructionsSetup instructionsARead-onlyIdempotent
Step-by-step checklist for connecting this server to Google: creating a Google Cloud project and a Desktop-app OAuth client, publishing the consent screen (mandatory — Testing-mode refresh tokens die after 7 days), downloading the client JSON and handing its PATH to set_client. Works without any credentials; the checklist shortens to 'enable the API + log in' when an OAuth client is already configured (one client serves the whole mcp-google-* line). Never asks the user to paste secrets into the chat.
Inputs: no named parameters.
start_loginStart the Google loginAIdempotent
First step of connecting from the chat, without editing config files or restarting the client. Returns authorizeUrl — show it to the user as a clickable link and ask them to open it in the browser ON THIS MACHINE, pick the Google account and approve access. A one-shot listener on 127.0.0.1 catches Google's redirect; the code is exchanged locally and never passes through the chat. Does not open the browser itself. The attempt lives 10 minutes; when the browser shows the success page, call finish_login.
Inputs: no named parameters.
update_entityUpdate a tag, trigger or variableADestructiveIdempotent
Updates a tag, trigger or variable by its API path. PUT semantics: this is a FULL REPLACE, not a patch — fetch the current resource with get_resource, modify it, and send the whole object back. Pass the resource's last-seen fingerprint for optimistic-concurrency safety; a mismatch fails the request. Requires the tagmanager.edit.containers scope.
Inputs: body (required), path (required), fingerprint.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 25 tools
The dedicated list/get tools (list_tags, list_triggers, list_variables, get_container, get_workspace) are clear, but the generic entity tools (get_resource, create_entity, update_entity, delete_entity) overlap heavily with the resource-specific ones, and it is not obvious when to use create_entity versus create_container/create_workspace. Multi-action tools (publish_version with publish/get/live, manage_built_in_variables with list/enable/disable) and six auth-related tools (set_client, start_login, finish_login, auth_status, setup_instructions, logout) further blur selection for an agent.
Nearly all tools follow a snake_case verb_noun pattern (get_account, list_containers, create_workspace, delete_entity, publish_version), which is predictable and readable. Minor deviations exist: logout is a bare verb, auth_status is noun-first, and setup_instructions is a noun phrase, so naming is mostly but not perfectly consistent.
At 25 tools this sits at the heavy end of the acceptable range for a domain with accounts, containers, workspaces, tags, triggers, variables, versions and publishing. However, six auth/setup tools plus a generic CRUD trio layered on top of resource-specific tools adds redundancy that inflates the surface beyond what the core GTM workflow needs.
Lifecycle coverage is strong: read/create/update/delete for tags, triggers and variables, plus workspaces, versions, publishing, built-in variables and full auth flow. Gaps are minor — no dedicated delete/update for containers, workspaces or accounts and no per-type get for tags/triggers — but raw_request serves as an escape hatch for environments, folders, templates, zones and these missing operations.
Maintenance
Related MCP Connectors
Hosted Google Tag Manager MCP server, with each action switched on or off per account.
Google Ads MCP server — manage campaigns, keywords, and metrics.
Read and edit GA4, Search Console and Google Tag Manager from any MCP client. 29 tools.
Hosted Google Analytics 4 MCP server, with each action switched on or off per account.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP Server that provides a conversational interface to Google Tag Manager API, allowing users to manage tags, triggers, variables, and containers through natural language.-
- AlicenseAqualityDmaintenanceMCP server for Google Tag Manager API, enabling users to manage containers, tags, and triggers through natural language using Google Application Default Credentials.1894 npmApache 2.0
- AlicenseNot gradedqualityDmaintenanceMCP server for Google Tag Manager API v2, enabling programmatic management of accounts, containers, workspaces, tags, triggers, variables, and version workflows.46 npm15MIT
- FlicenseNot gradedqualityBmaintenanceA remote MCP server for Google Tag Manager that enables AI assistants to manage GTM accounts, containers, tags, triggers, variables, and more via OAuth or service account authentication.1-