Gtm MCP Server

The GTM MCP Server is a tool based on the Model Context Protocol that allows users to manage Google Tag Manager containers in natural language through AI assistants (such as Claude, ChatGPT, Gemini), enabling functions such as tag creation, configuration auditing, tracking plan generation, and change publishing.

Marketing Developer tools #Tag management #AI automation #Container operation #Template import .Go

rating : 2.5 points

downloads : 5.1K

update time : 2026-03-13

Open Site

What is GTM MCP Server?

GTM MCP Server is a bridge that connects AI assistants (such as Claude, ChatGPT, Gemini) with the Google Tag Manager API. It allows you to manage website tracking codes through natural language conversations without manually clicking on the GTM interface. Just tell the AI what you want to achieve, and it will automatically create tags, set triggers, manage variables, etc.

How to use GTM MCP Server?

It's very simple to use: 1) Add the MCP connector to the AI assistant; 2) Authorize access to your Google account; 3) Start managing GTM with natural language. For example, tell the AI 'Create a GA4 event tag for form submission', and it will automatically complete all technical configurations.

Use cases

Suitable for website administrators, digital marketers, data analysts, developers, and marketing agencies. Especially suitable for scenarios such as quickly setting up new website tracking, batch - managing multiple containers, standardizing tracking implementation, generating tracking documents, and integrating third - party tools.

Main features

Tag management

Create and modify any GTM tag types, including GA4 configurations, e - commerce events, custom HTML, custom images, etc. The AI will automatically configure the correct parameters according to your description.

Trigger management

Build triggers for various scenarios: page views, custom events, click tracking, form submissions, timers, etc. Support complex condition combinations.

Container audit

Automatically analyze the workspace, detect naming inconsistencies, duplicate tags, orphaned triggers, security issues, etc., and provide improvement suggestions.

Tracking plan generation

Automatically generate a tracking plan document in Markdown format, including all event, trigger, and variable definitions and implementation instructions.

Server - side container support

Fully support server - side GTM containers, including advanced functions such as client - side management and conversion rule settings.

Community template library

Import templates directly from the Google community template library, such as Cookie consent management, Facebook Pixel, etc. The AI will automatically search and install them.

Bulk operations

Rename, update, or organize dozens of tags and triggers in batches through simple instructions to improve management efficiency.

Version control

All changes are first made in the workspace. Only after creating a version can you publish the changes, ensuring security and controllability.

Advantages

No technical knowledge required: Describe your requirements in natural language, and the AI will handle the technical details.

Save time: Complete manual configurations that originally took hours in just a few minutes.

Reduce errors: The AI follows best practices to avoid human - made configuration errors.

Unified standards: Ensure consistency in the implementation of all containers.

Real - time collaboration: Interact with the AI in a conversational way and adjust configurations immediately.

Safe and controllable: Deletion or publishing operations require confirmation before execution.

Multi - platform support: Compatible with mainstream AI assistants such as Claude, ChatGPT, and Gemini.

Limitations

Google account authorization required: You must authorize access to the GTM API.

Network dependency: A stable network connection is required.

Learning curve: You need to understand basic GTM concepts and terms.

API limitations: Subject to the rate limits of the Google Tag Manager API.

Specific function limitations: Some advanced trigger conditions need to be configured manually.

How to use

Select an AI assistant

Select the AI assistant you use: Claude (web version or desktop version), ChatGPT, or Gemini CLI.

Add the MCP connector

Add a custom MCP connector in the settings of the AI assistant and enter the server URL: https://mcp.gtmeditor.com

Authorize your Google account

Click the authorization button, log in with your Google account, and grant access to the GTM API. Your credentials will not be stored.

Start conversational management

Now you can manage GTM with natural language. For example: 'List all my containers' or 'Create a GA4 tag for purchase events'.

Review and publish

The AI will first make changes in the workspace. You can review them and then decide whether to create a version and publish it to the production environment.

Usage examples

Complete e - commerce tracking setup

Set up complete GA4 e - commerce tracking for a newly launched e - commerce website, including all standard events such as product browsing, adding to cart, starting checkout, and purchasing.

Consent management integration

Integrate a consent management platform (such as OneTrust) with website tracking to ensure that analytics tags are only triggered when the user gives consent.

Bulk renaming and organization

Add a unified prefix to dozens of tags and triggers in a large container and organize them into folders to improve maintainability.

Import tools from the template library

Import third - party tools from the Google community template library, such as Cookie consent management or social media pixels.

Generate a tracking plan document

Generate a detailed tracking implementation document for the development team, explaining all events, data layer requirements, and implementation steps.

Frequently Asked Questions

Is my Google account credential secure?

Will the AI directly publish changes to the production environment?

Which AI assistants are supported?

Do I need technical knowledge?

Can I manage containers for multiple clients?

Are there API rate limits?

Can I undo the changes made by the AI?

Does it support server - side GTM?

Related resources

GitHub repository

Complete source code, issue tracking, and contribution guidelines

GTM API reference

GTM API documentation optimized for LLMs, including request templates and validation rules

MCP protocol specification

Official documentation and specification of the Model Context Protocol

Google Tag Manager API

Official Google Tag Manager API documentation

Docker image

Official Docker container image

Issue feedback

Report issues, request features, or provide feedback

🚀 GTM MCP Server

Let AI manage your Google Tag Manager containers. Create tags, audit configurations, generate tracking plans, and publish changes, all through natural conversation with Claude, ChatGPT, or Gemini.

URL: https://mcp.gtmeditor.com

🚀 Quick Start

Claude (Web & Desktop)

Claude.ai:

Go to Settings → Connectors → Add Custom Connector
Enter: https://mcp.gtmeditor.com
Click Add and sign in with Google

Claude Code (CLI):

claude mcp add -t http gtm https://mcp.gtmeditor.com

ChatGPT

Go to OpenAI Apps Platform
Add an MCP integration with URL: https://mcp.gtmeditor.com
Authorize with your Google account

Gemini CLI

gemini mcp add --transport http --url https://mcp.gtmeditor.com gtm

✨ Features

Tag Management

Create and modify any GTM tag type:

GA4 Configuration & Events — Set up Google Analytics 4 with proper measurement IDs
Ecommerce Tracking — Purchase, add-to-cart, view-item events
Custom HTML — Inject scripts, pixels, and custom code
Custom Image — Tracking pixels with cache busting

Trigger Management

Build triggers for any scenario:

Page views (all pages or specific URLs)
Custom dataLayer events
Click tracking
Form submissions
Timer-based triggers
Trigger groups for complex conditions

Container Operations

Browse accounts, containers, and workspaces
Create versions from workspace changes
Publish versions to go live
Organize with folders
Enable/disable built-in variables

Server-Side Containers

Full support for server-side GTM containers:

Clients — Create, update, and delete server-side clients (e.g. GA4 client)
Transformations — Control event parameters with allow, exclude, and augment rules

Community Template Gallery

Import templates from Google's Community Template Gallery:

"Import the iubenda cookie consent template"
"Add Cookiebot to my container"
"Set up Facebook Pixel using the gallery template"

The AI will search for the template, find the GitHub repository, and import it automatically.

AI-Powered Workflows

Container Audit "Audit my container for issues" — Analyzes your workspace for:

Naming inconsistencies
Duplicate tags
Orphaned triggers
Security concerns
Best practice violations

Tracking Plan Generation "Generate a tracking plan" — Creates markdown documentation of:

All events and their triggers
Data layer requirements
Variable definitions
Implementation notes

GA4 Setup Recommendations "Help me set up GA4 for ecommerce" — Recommends:

Which tags to create
Trigger configurations
Required variables
Data layer implementation code

💻 Usage Examples

Build Complete Tracking Setups

Ask AI to create a full GA4 ecommerce implementation from scratch:

"Set up GA4 ecommerce tracking for my store"
Creates 12+ tags (configuration + all ecommerce events)
Creates matching triggers for each dataLayer event
Creates data layer variables for items, currency, value, transaction_id
Follows Google's recommended event naming and parameters

Implement Consent Management

Integrate privacy tools like OneTrust with your tracking:

"Make GA4 fire only when analytics consent is granted"
Creates consent-checking variables
Sets up conditional triggers
Updates existing tags to respect user choices

Bulk Operations & Renaming

Manage containers at scale:

"Add 'ecom -' prefix to all ecommerce triggers"
"Update all tags to use a measurement ID variable"
Rename, update, or organize dozens of items through conversation

Custom Variables & Logic

Create sophisticated tracking logic:

"Create a variable that returns the local timestamp"
"Add a custom parameter to the purchase tag"
Custom JavaScript variables, data layer mappings, and more

For Agencies

Manage multiple client containers (7+ accounts shown in demo)
Standardize implementations across clients
Rapid setup for new projects
Version and publish changes safely

📚 Documentation

How It Works

The GTM MCP Server connects AI assistants to the Google Tag Manager API using the Model Context Protocol. When you ask Claude or ChatGPT to manage your GTM, it:

Authenticates with your Google account (OAuth 2.1)
Reads your container configurations
Executes the changes you request
Confirms before destructive operations

Your credentials are never stored—the server uses token-based authentication that you can revoke anytime from your Google account.

Safety Features

Confirmation required for deletions and publishing
Workspace-only changes — nothing goes live until you publish
Version control — all changes create a version first
Audit logging — track what was changed

Self-Hosting

Want to run your own instance?

Docker Setup

git clone https://github.com/paolobietolini/gtm-mcp-server.git
cd gtm-mcp-server

# Create .env file
cat > .env << 'EOF'
GOOGLE_CLIENT_ID=your-client-id.apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=your-client-secret
JWT_SECRET=$(openssl rand -base64 32)
BASE_URL=http://localhost:8080
EOF

# Start the server
docker compose up -d

# Add to Claude
claude mcp add -t http gtm http://localhost:8080

Docker-to-Docker

If another container needs to reach the MCP server via an internal Docker network alias, add ALLOWED_HOSTS to your .env:

ALLOWED_HOSTS=gtm-mcp:8080

This enables dynamic URL resolution for trusted internal hostnames while keeping the server secure against host header injection.

Google Cloud Setup

Go to Google Cloud Console
Enable the Tag Manager API
Create OAuth 2.0 credentials (Web application)

Add redirect URIs:

https://claude.ai/api/mcp/auth_callback
https://claude.com/api/mcp/auth_callback
https://chatgpt.com/connector_platform_oauth_redirect
https://your-domain.com/oauth/callback

Available Tools

Read Operations

Tool	Description
`list_accounts`	List all GTM accounts
`list_containers`	List containers in an account
`list_workspaces`	List workspaces in a container
`list_tags`	List all tags in a workspace
`get_tag`	Get tag details by ID
`list_triggers`	List all triggers
`get_trigger`	Get trigger details by ID
`list_variables`	List all variables
`get_variable`	Get variable details by ID
`list_folders`	List folders in a workspace
`get_folder_entities`	Get tags/triggers/variables in a folder
`list_built_in_variables`	List enabled built-in variables in a workspace

Utility

Tool	Description
`ping`	Test server connectivity
`auth_status`	Check authentication status

Write Operations

Tool	Description
`create_container`	Create a new container in an account
`delete_container`	Remove a container (requires confirmation)
`create_workspace`	Create a new workspace in a container
`create_tag`	Create a new tag
`update_tag`	Modify an existing tag
`delete_tag`	Remove a tag (requires confirmation)
`create_trigger`	Create a new trigger
`update_trigger`	Modify an existing trigger
`delete_trigger`	Remove a trigger (requires confirmation)
`create_variable`	Create a new variable
`update_variable`	Modify an existing variable
`delete_variable`	Remove a variable (requires confirmation)
`enable_built_in_variables`	Enable built-in variable types in a workspace
`disable_built_in_variables`	Disable built-in variable types (requires confirmation)

Server-Side Container Tools

Tool	Description
`list_clients`	List all clients in a workspace
`get_client`	Get client details by ID
`create_client`	Create a new client
`update_client`	Modify an existing client
`delete_client`	Remove a client (requires confirmation)
`list_transformations`	List all transformations in a workspace
`get_transformation`	Get transformation details by ID
`create_transformation`	Create a new transformation
`update_transformation`	Modify an existing transformation
`delete_transformation`	Remove a transformation (requires confirmation)

Publishing

Tool	Description
`get_workspace_status`	Check pending changes and merge conflicts before versioning
`list_versions`	List all container versions with tag/trigger/variable counts
`create_version`	Create a version from workspace changes
`publish_version`	Publish a version (requires confirmation)

Templates

Tool	Description
`get_tag_templates`	Get GA4/HTML tag parameter examples
`get_trigger_templates`	Get trigger configuration examples
`list_templates`	List custom templates in a workspace
`get_template`	Get template details including template code
`create_template`	Create a custom template from .tpl code
`update_template`	Modify an existing template
`delete_template`	Remove a template (requires confirmation)
`import_gallery_template`	Import a template from the Community Gallery

Resources & Prompts

Resources (URI-based access)

Access GTM data via structured URIs:

gtm://accounts
gtm://accounts/{id}/containers
gtm://accounts/{id}/containers/{id}/workspaces
gtm://accounts/.../workspaces/{id}/tags
gtm://accounts/.../workspaces/{id}/triggers
gtm://accounts/.../workspaces/{id}/variables

Prompts (Workflow templates)

Prompt	Description
`audit_container`	Comprehensive container analysis
`generate_tracking_plan`	Markdown documentation generator
`suggest_ga4_setup`	GA4 implementation recommendations
`find_gallery_template`	Guide to find and import Community Gallery templates

Better AI Context

For best results, install the GTM API skill so your AI assistant understands GTM's API structure, parameter formats, and validation rules.

Claude Code

# One-liner install
curl -sL https://github.com/paolobietolini/gtm-api-for-llms/archive/main.tar.gz | tar xz && \
  mkdir -p ~/.claude/skills && \
  cp -r gtm-api-for-llms-main/skills/gtm-api ~/.claude/skills/ && \
  rm -rf gtm-api-for-llms-main

Or clone and copy:

git clone https://github.com/paolobietolini/gtm-api-for-llms.git
cp -r gtm-api-for-llms/skills/gtm-api ~/.claude/skills/

OpenAI Codex

curl -sL https://github.com/paolobietolini/gtm-api-for-llms/archive/main.tar.gz | tar xz && \
  mkdir -p ~/.codex/skills && \
  cp -r gtm-api-for-llms-main/skills/gtm-api ~/.codex/skills/ && \
  rm -rf gtm-api-for-llms-main

What does the skill include?

The GTM API for LLMs repository provides LLM-optimized documentation: request templates, validation rules, workflow algorithms, and complete schemas for all GTM entity types including server-side containers.

Architecture

Protocol: Model Context Protocol (MCP) over HTTP
Authentication: OAuth 2.1 with PKCE
Standards: RFC 8414, RFC 7591, RFC 9728

Known Issues

🐛 `autoEventFilter` silently dropped by Google Tag Manager API

When creating or updating linkClick, click, or formSubmission triggers via the API, the autoEventFilter field (used for "Some Link Clicks"/"Some Form Submissions" conditions) is silently dropped by the Google Tag Manager API. The API returns 200 OK with a new fingerprint but does not persist the autoEventFilter.

This has been confirmed by HTTP-level debugging: the correct JSON is sent in the request body, but Google's response omits the field. The filter and customEventFilter fields work correctly.

Workaround: Configure autoEventFilter conditions manually through the GTM web interface. The MCP server can read triggers that have autoEventFilter set via the UI.

Status: #33