MCP App Store
by KeenEthics
Metrifyr icon

Metrifyr MCP Server for ChatGPT

By Tomas Grasl

Overview

Metrifyr connects your AI assistant to the marketing data you already own. Sign in with Google once and ask in plain language: why traffic dropped last week, which pages lost clicks, which queries sit on page two, whether a URL is indexed, how AI assistants send you visitors, or what changed in your GA4 property. Data sources: Google Analytics 4 (reports, realtime, funnels, period comparisons, property admin, annotations, change history), Search Console (performance, URL inspection, sitemaps, coverage audit), Tag Manager (audit and edits), AdSense, Google Indexing API and IndexNow, Bing Webmaster Tools, Microsoft Clarity, PageSpeed Insights and Chrome UX Report, plus keyword research from free sources. Beyond raw reports, Metrifyr ships workflows: traffic-drop diagnosis, content decay, keyword cannibalization, striking-distance opportunities, an interactive Search Console dashboard, and server-side monitoring with rank tracking, Core Web Vitals tracking, alerts and scheduled digests that run without an open chat. Read-only by default. Write actions need an explicit extra permission and are marked as such. Data is fetched live from Google on your behalf and is not used for training.

How to connect

  1. ChatGPT: Open the Metrifyr listing in the ChatGPT app directory and choose Connect. ChatGPT listing Metrifyr exposes 110 tools here.

Tools

ads_campaign_plan

ChatGPT
[READ] Generate a structured, review-ready Google Ads Search campaign blueprint from a brief. Give it the campaign goal (brief) and the finalUrl, plus any keywords you have already gathered. It returns a complete plan: reconciled budget, tightly-themed ad groups, keywords with recommended match types, negative-keyword guidance, and an RSA slot checklist (with char limits) for you to fill with grounded copy. Best results — chain these first and pass the output back in as keywords: - keyword_suggest — expand the topic into long-tail variants - gsc_search_analytics — real queries you already get impressions for (→ keywords AND negatives) - ga4_run_report — top landing pages, geo, converting segments - seo_audit on the finalUrl — landing-page quality is a Quality Score proxy Real demand numbers: when a Bing Webmaster key is connected, each keyword comes back with monthlyVolume (real Bing volume) and googleVolumeEstimate (× 10 proxy), and keywords and ad groups are ordered by demand. Volumes are looked up for the market in locations / languages (e.g. ["Japan"] → JP / ja-JP) and volume.market says which; with no country in the brief they are US numbers, flagged in volume.warnings. With no volume source the volume block says so explicitly — do not present unranked keywords as vetted. CPC estimates are available from no free source; use the Ads UI's Keyword Planner. Export: export.googleAdsEditorCsv is a Google Ads Editor–compatible CSV of ad groups, keywords (one row per match type) and campaign negatives, so the plan can be pasted in rather than retyped. Ad copy is excluded on purpose — the RSA slots are guides, not finished ads. This tool is review-only: it does not connect to or write to a Google Ads account and nothing is published. readiness.readyToExport is always false in this phase — it lists what is still needed before a campaign could be created. Next: thin keyword list → keyword_suggest + gsc_search_analytics, then re-run with the enriched keywords; landing-page quality (Quality Score proxy) → seo_audit on finalUrl; before any launch → conversion tracking via ga4_create_conversion_event or a GTM Ads conversion tag

adsense_generate_report

ChatGPT
[READ] Generate an AdSense report with earnings, page views, clicks, and impressions. Window: startDate + endDate (YYYY-MM-DD), or a preset dateRange (LAST_7_DAYS, LAST_30_DAYS, MONTH_TO_DATE, YEAR_TO_DATE, TODAY, YESTERDAY). Narrow big reports with filters (e.g. ["DOMAIN_NAME==example.com"]) and get a top-N with orderBy (["-ESTIMATED_EARNINGS"]) + limit. Money values are in the account currency — read the top-level currencyCode (e.g. "CZK", "EUR") and never assume USD. Next: earnings drop → ga4_compare_periods to isolate traffic vs yield

adsense_get_account

ChatGPT
[READ] Read one AdSense account's details: display name, state, time zone and premium status.

adsense_keyword_revenue

ChatGPT
[READ] Rank your organic pages by the AdSense revenue they actually earn — joins Search Console clicks with AdSense per-page earnings (PAGE_URL) on a normalized URL, then computes page RPM, estimated organic revenue (clicks × RPM), and the organic share of each page's traffic. Optionally attaches the top organic queries per page, so you see which KEYWORDS make money, not just which pages get clicks. Use this to prioritize content work by revenue instead of traffic: a 200-click page at $12 RPM beats a 2000-click page at $0.40 RPM. Both a Search Console property and an AdSense account must be connected (call gsc_list_sites and adsense_list_accounts first if you don't have the IDs). Numbers are estimates: AdSense counts all page views (not just organic), so estimatedOrganicRevenue assumes RPM is uniform across traffic sources.

adsense_list_accounts

ChatGPT
[READ] List the AdSense accounts this connection can read. Start here to get an accountId for the other AdSense tools.

adsense_list_ad_clients

ChatGPT
[READ] List the ad clients (products such as AdSense for Content) of an AdSense account.

adsense_list_ad_units

ChatGPT
[READ] List the ad units of an AdSense ad client, with their state and content-ad settings.

adsense_list_payments

ChatGPT
[READ] List the payments of an AdSense account (amount and date).

ai_bot_access_check

ChatGPT
[READ] Check which AI engines can read a site: fetches robots.txt, evaluates it for every major AI crawler (GPTBot, OAI-SearchBot, ClaudeBot, PerplexityBot, Google-Extended, Bingbot, CCBot …), and spot-checks the edge with UA-spoofed requests to catch WAF/CDN user-agent blocks. Verdicts distinguish what a block actually costs you: training crawlers (model corpora), search-index crawlers (ChatGPT search / Perplexity / Copilot citations — blocking these removes you from AI answers), and user-action fetchers (largely ignore robots.txt). summary.fullyOpenToAi is true only when no AI crawler is blocked by robots.txt, none is blocked at the edge (summary.blockedAtEdge), and robots.txt is reachable — a robots.txt answering 5xx / 401 / 403 / 429 or timing out makes crawlers treat the whole site as disallowed (summary.robotsTxtStatus: "unreachable", with a warning). A 404 robots.txt means no rules (everything allowed). Limits stated in the response: requests come from Metrifyr's IP, so IP-reputation blocking (e.g. Cloudflare AI Crawl Control) is not detectable — the edge check only catches UA-based rules.

alerts_list

ChatGPT
[WRITE] List monitoring alerts produced by scheduled checks (newest first). By default returns only unacknowledged alerts and marks them acknowledged, so the next call shows only what is new since you last looked. Pass includeAcknowledged: true for full history. Example: {} → "what happened since I was last here"

auth_status

ChatGPT
Check authentication status and connected services. Pass checkGoogleAccount: true to also report which Google account the key is connected with (googleAccountEmail) — use it when Google denies access to a site or property the user says they own.

competitor_sitemap_keywords

ChatGPT
[READ] Extract the keywords a competitor targets by walking their sitemap and tokenising URL slugs. For sites with deep slug-based URL structures (games portals, blogs, marketplaces, docs sites) this is a $0 proxy for content-gap analysis — no API keys needed, no scraping, just the public sitemap. Returns ranked keyword phrases plus a histogram of top path segments (e.g. "/games", "/blog") so you can see how the competitor organises their content surface. Discovery chain: explicit sitemap_url → robots.txt → /sitemap.xml → /sitemap_index.xml. Sitemap-index entries are followed to depth 2, gzipped (.xml.gz) sitemaps are auto-decompressed. Pairs naturally with keyword_suggest (volumes/long-tail discovery) and serp_intent_analyzer (intent classification per keyword).

content_decay_scan

ChatGPT
[READ] Find which pages are LOSING organic traffic — compares Search Console clicks per page across two equal 28-day windows (default: last 28 days vs the 28 days before; window="yoy" compares against the same window one year earlier for seasonal content), joins the periods on a normalized URL, and ranks pages by decayScore = relative click decline × log10(previous clicks + 1) — so a big page losing half its traffic outranks a tiny page losing all of it. Optional enrichment (each skipped gracefully when the input or scope is missing — check the enrichment block): - adsenseAccountId → joins AdSense page RPM from the baseline window and adds revenueAtRisk per page (lost clicks × RPM), turning traffic decay into money terms - ga4PropertyId → adds the GA4 sessions delta per page, separating search-only decay from a site-wide traffic problem Use this as the recurring "what should we refresh next?" scan on established sites. Windows end 3 days ago (finalized GSC data; exact dates echoed in dateRanges); check fetched.possiblyTruncated before claiming full coverage. Next: top decaying pages → run the seo-content-refresher prompt (gsc_search_analytics + ga4_compare_periods per page) to build the refresh plan; decayed page still at positions 4–15 → striking_distance_optimizer to size the recovery push; worst single URL → url_full_report for the full health check (CWV, queries, schema)

content_opportunity_finder

ChatGPT
[READ] Find content opportunities by combining Google Trends rising topics with Search Console pages that have low CTR or high impression share. Identifies gaps where trending topics could improve existing content. Returns opportunities categorized as: - High: page-1 queries (position ≤ 10) whose CTR is below half of what that position normally earns (published organic CTR curve) — a title/meta rewrite pays off. Ranked by missed clicks; scanned over the top 5000 queries, not just the ones that already get clicks. - Medium: Rising trends matching queries you already rank for - Low: General trending topics worth considering Queries at positions 11–20 are not listed as CTR fixes (they need a ranking push) — strikingDistance.count says how many there are; run striking_distance_optimizer for them. The GSC window ends 3 days ago (data lag). Example usage: - Basic: { "siteUrl": "sc-domain:example.com" } - With industry: { "siteUrl": "sc-domain:example.com", "industry": "technology", "geo": "US" } Next: page already ranks 4–15 → striking_distance_optimizer for that query/page; new page → keyword-research skill for full cluster

cwv_crux_history

ChatGPT
[READ] Real-user Core Web Vitals history for a site or page from the Chrome UX Report — up to 40 weekly data points (≈10 months) of p75 LCP, INP, CLS and TTFB plus the share of "good" loads, in one call and with nothing to set up. Use it before cwv_tracker_add: it answers "has performance been getting worse, and since when?" from data Chrome already collected, while the tracker starts recording from today. Pass an origin ("https://example.com") for the whole site or a url for one page (URL-level data exists only for pages with enough Chrome traffic — the tool says so and suggests the origin). Each metric comes back with p75 per week, the good-share per week, the latest band (good / needs-improvement / poor) and a trend verdict. Data is a 28-day rolling window per point, updated weekly by Google; there is nothing fresher than last Monday in it — for today's numbers use psi_analyze.

cwv_tracker_add

ChatGPT
[WRITE] Start tracking Core Web Vitals for specific page URLs. LCP, INP, CLS and the performance score are snapshotted daily from PageSpeed Insights and alerts fire when a metric crosses into the Poor band or regresses a rating band (Good → Needs Improvement → Poor). Each tracked URL costs one PSI call per day, so track your money pages, not every URL. Limit: 20 URLs per site. URLs must be on the siteUrl's domain. Search Console access is not required, but when the account has the domain under another property id (e.g. sc-domain:example.com) the call asks you to use that id, so CWV is grouped with the site's other monitoring. Tip: pick URLs from gsc_search_analytics top pages or adsense_keyword_revenue — the pages where a CWV regression actually hurts. Example: { "siteUrl": "https://example.com", "urls": ["https://example.com/", "https://example.com/pricing"] }

cwv_tracker_history

ChatGPT
[READ] Core Web Vitals history for tracked URLs (time series, sparkline-friendly). Each data point carries the performance score plus LCP/INP/CLS values (and, from 2.60, whether each came from CrUX field data or a Lighthouse lab run). Days where the PSI call failed have no data point; lastRun says whether the latest daily run worked and, if not, why. Examples: - All URLs, last 30 days: { "siteUrl": "https://example.com" } - One URL, last 90 days: { "siteUrl": "https://example.com", "url": "https://example.com/pricing", "days": 90 }

cwv_tracker_remove

ChatGPT
[WRITE] Stop tracking Core Web Vitals for URLs. Omit "urls" to remove all tracked URLs for the site (this also disables the daily snapshot check). Vitals history is kept. Example: { "siteUrl": "https://example.com", "urls": ["https://example.com/pricing"] }

digest_schedule_list

ChatGPT
[READ] List configured email digest schedules with cadence, recipient, sections and send times. Example: {}

digest_schedule_remove

ChatGPT
[WRITE] Remove the email digest schedule for a site. No more digests are sent; monitoring checks and alerts are unaffected. Example: { "siteUrl": "https://example.com" }

digest_schedule_set

ChatGPT
[WRITE] Schedule a recurring email digest for a site (upsert — one digest per site). Metrifyr assembles a summary and emails it on the chosen cadence. Sections (default: all available): - gsc: Search Console clicks/impressions/position, 7 days vs previous 7, with top gaining/losing queries - ga4: GA4 sessions, 7 days vs previous 7 (requires ga4PropertyId) - rank: biggest position movers among rank-tracker keywords (set them up with rank_tracker_add) - alerts: count of open monitoring alerts Limit: 5 digest schedules per API key. Emails include a one-click unsubscribe link. Access is verified before saving: a siteUrl that is not one of this key's Search Console properties is rejected with the property id the account does have (e.g. sc-domain:example.com), and an unreadable ga4PropertyId is rejected with matching properties it can read. Examples: - { "siteUrl": "https://example.com", "recipientEmail": "me@example.com" } - { "siteUrl": "sc-domain:example.com", "recipientEmail": "me@example.com", "cadence": "daily", "ga4PropertyId": "properties/123456789", "sections": ["gsc", "ga4"] }

feedback_submit

ChatGPT
[WRITE] Send feedback about Metrifyr's MCP tools to the Metrifyr team. This closes the loop — it writes to the team's feedback inbox, which they triage and act on. WHEN TO CALL THIS (proactively, on a real signal): - A tool returned a wrong, confusing, or malformed result -> category "bug" (set toolName). - The user asks you to pass on a request or complaint about the tools -> category "improvement" or "missing_tool", reporter "user". - You (or the user) needed a capability that no tool provides -> category "missing_tool". File it directly — do not offer it to the user as an option or ask permission first; just tell them afterwards. Name the Google API / endpoint if you know it supports the capability. - Genuine praise worth passing on -> category "praise". WHAT TO SEND: describe the tool behavior or the request. Do NOT include the user's personal data, account contents, secrets, or API keys in the message — keep it about the tooling. TRANSPARENCY: when you submit feedback on your own initiative (not because the user explicitly asked), briefly tell the user you did so (e.g. "I've sent feedback about this to the Metrifyr team"). When you are relaying the user's own words (reporter "user"), no extra disclosure is needed. This records the feedback; it does not fix the issue or guarantee a reply.

ga4_ai_traffic_report

ChatGPT
[READ] AI traffic report for a GA4 property: how much traffic AI assistants send you and how it converts, versus Organic Search. Combines GA4's native "AI Assistant" channel group with a referrer-source patch for the assistants Google's channel misses (Claude, Perplexity, Mistral and others), deduplicated. Returns per-assistant sessions/users/key events, share of total sessions, and an Organic Search comparison. conversionRatePct is the % of sessions with at least one key event (GA4 sessionKeyEventRate, never above 100); keyEventsPerSession is reported separately. Default window 30daysAgo…yesterday in the property's time zone. Caveat baked into the response: assistants often open links without a referrer — that traffic lands in Direct and cannot be recovered. Treat every number as a floor.

ga4_archive_custom_dimension

ChatGPT
[WRITE] Archive a GA4 custom dimension: it disappears from reports and frees its slot. The Admin API cannot restore it. Find it by definitionName or parameterName (+ scope when the name is used twice).

ga4_archive_custom_metric

ChatGPT
[WRITE] Archive a GA4 custom metric: it disappears from reports and frees its slot. The Admin API cannot restore it. Find it by definitionName or parameterName.

ga4_batch_run_reports

ChatGPT
[READ] Run multiple GA4 reports in a single request. Each request accepts the ga4_run_report options: dimensionFilter/metricFilter, limit (default 250 rows) and offset, orderBys (set it for top-N), metricAggregations (["TOTAL"] → totals) and keepEmptyRows. Each report carries its own fetched and warnings.

ga4_change_history

ChatGPT
[READ] GA4 change history: who changed what in a property's configuration, and when — key events, custom dimensions/metrics, data streams, retention, links, audiences, annotations, property settings. Use it to answer "did someone change the GA4 setup around the date the numbers moved?". Defaults to the last 30 days, newest first, 100 changes. Filter with resourceTypes (e.g. ["KEY_EVENT","CUSTOM_DIMENSION","DATA_STREAM","REPORTING_DATA_ANNOTATION","PROPERTY"]), actions (CREATED/UPDATED/DELETED) and actorEmails. Each row carries the resource before and after the change (set includeDetails:false for a compact list). Google requires the GA4 edit permission for this API, so it is available on connections with GA4 admin access.

ga4_compare_periods

ChatGPT
[READ] Compare GA4 metrics between two time periods. Returns current/previous values with absolute and percentage changes. Period semantics: - Preset period values ("day", "week", "month", "quarter", "year" = 1/7/30/90/365 days ending yesterday) auto-derive the previous window of equal duration immediately preceding the current one. "Yesterday" is the property's yesterday (GA4 resolves the dates in the property time zone), and the response shows the resolved dates plus metadata.timeZone. - Custom mode: pass customCurrentStart/End AND customPreviousStart/End explicitly — nothing is auto-shifted, both windows are exactly what you specify. Filtering: pass dimensionFilter (same FilterExpression shape as ga4_run_report) to compare a subset — e.g. one page — period over period, e.g. {"filter":{"fieldName":"pagePath","stringFilter":{"matchType":"EXACT","value":"/blog/my-article"}}}. Parallel-safe: if comparing multiple metrics or properties, call this tool in parallel — each call is independent. Next: pages down >20% → content_decay_scan, then the seo-content-refresher prompt per page; pages down 5–20% → gsc_search_analytics to find drifting queries; any drop → psi_analyze to rule out speed regressions

ga4_create_annotation

ChatGPT
[WRITE] Add an annotation to GA4 report charts: a title and either one date or a startDate–endDate range, with optional description and color. Needs the Analyst role on the property; GA4 allows up to 1 000 annotations per property. Annotations Google creates itself (systemGenerated: true) are read-only. Dates are in the property's time zone. Uses the GA4 Admin API v1alpha (reportingDataAnnotations), which Google may change without notice.

ga4_create_conversion_event

ChatGPT
[WRITE] Mark an event as a GA4 key event (formerly "conversion"), with an optional counting method and default value.

ga4_create_custom_dimension

ChatGPT
[WRITE] Register an event, user or item parameter as a GA4 custom dimension. Data is available from the registration date onwards.

ga4_create_custom_metric

ChatGPT
[WRITE] Register a numeric event parameter as a GA4 custom metric. Data is available from the registration date onwards.

ga4_create_data_stream

ChatGPT
[WRITE] Create a GA4 data stream (web, iOS or Android) on a property. WEB needs defaultUri; IOS and ANDROID need packageName. Returns the stream and, for web, its measurement ID.

ga4_create_property

ChatGPT
[WRITE] Create a new GA4 property under an account. Returns the new property ID.

ga4_delete_annotation

ChatGPT
[WRITE] Delete a GA4 annotation. Annotations Google creates itself cannot be deleted.

ga4_delete_conversion_event

ChatGPT
[WRITE] Remove the key-event marking from a GA4 event. The event and its data stay; it just stops counting as a key event.

ga4_delete_property

ChatGPT
[WRITE] Move a GA4 property to the trash. Google deletes it permanently after 35 days unless it is restored in the GA4 admin.

ga4_funnel_report

ChatGPT
[READ] Run a GA4 funnel report: how many users reach each step of an ordered journey, and where they drop off. Use this instead of stitching several ga4_run_report calls together — GA4 evaluates step order and de-duplicates users per step server-side, which you cannot reproduce correctly from separate event counts. Returns the drop-off math already computed: per step users, completionPercentFromFirstStep, dropOffFromPreviousStep (absolute users lost vs. the previous step) and dropOffPercentFromPreviousStep, plus an overall block with biggestDropOff — the step transition losing the most users. Do NOT recompute these from raw event counts. Defining steps. Shorthand (preferred): {"name":"Viewed pricing","eventName":"page_view","dimension":{"fieldName":"pagePath","matchType":"EXACT","value":"/pricing"}} — eventName and dimension are ANDed. Escape hatch: pass a raw GA4 filterExpression (FunnelFilterExpression) instead. Min 2, max 10 steps; order matters. Closed vs open: isOpenFunnel defaults to false (closed — users must enter at step 1, the usual intent). In an OPEN funnel users may enter at any step, so a later step can have MORE users than the one before it and dropOffFromPreviousStep may be negative — that is meaningful, not an error. breakdownDimension (e.g. "deviceCategory") splits every step and returns a breakdown block. Note that users is de-duplicated per breakdown value, so you must NOT sum breakdown values back into a total. At most 250 funnelTable rows unless you pass limit (enough for 10 steps × 15 breakdown values); fetched.possiblyTruncated flags a full page. ⚠️ ALPHA API: this calls the GA4 Data API v1alpha runFunnelReport endpoint. Google states it is "introduced at alpha stability with the intention of gathering feedback on syntax and capabilities before entering beta" — the request/response shape may change without notice. Next: biggest drop-off step → ga4_run_report on that step page for context; drop-off concentrated on one device/source → re-run with breakdownDimension; landing step underperforming → psi_analyze on that URL

ga4_get_annotation

ChatGPT
[READ] Read one GA4 annotation by its id.

ga4_get_data_retention

ChatGPT
[READ] Read how long a GA4 property keeps event-level and user-level data.

ga4_get_measurement_id

ChatGPT
[READ] Get the measurement ID (G-XXXXXXXXXX) for a web data stream

ga4_get_privacy_settings

ChatGPT
[READ] Read a GA4 property's privacy and data-collection settings in one call — the checklist for privacy hardening before tagging goes live (health, finance, legal and other regulated sites): - Google signals (on/off, terms consent) - user-provided data collection and automatic detection of it - data retention (event- and user-level) - the account's data-sharing settings (Google products, technical support, benchmarking, sales) - per web stream: enhanced measurement (page changes from history events, scrolls, outbound clicks, site search, form interactions, video, file downloads) and data redaction (email addresses, chosen URL query parameters) Each section reports its own error without failing the others. Pass streamId to check one web stream instead of all. notAvailableViaApi lists the settings Google keeps out of the API (granular location/device data, ads personalization per region, unwanted referrals) with their place in the GA4 UI — tell the user to change those by hand. Change the rest with ga4_update_google_signals, ga4_update_enhanced_measurement and ga4_update_data_redaction. Uses the GA4 Admin API v1alpha, which Google may change without notice.

ga4_get_property

ChatGPT
[READ] Get details of a specific GA4 property

ga4_get_realtime

ChatGPT
[READ] Get real-time visitor data from GA4 — who is on the site in the last 30 minutes. This is the Realtime API, which has its own small schema, NOT the ga4_run_report catalogue. Dimensions (only these): appVersion, audienceId, audienceName, city, cityId, country, countryId, deviceCategory, eventName, minutesAgo, platform, streamId, streamName, unifiedScreenName. Metrics (only these): activeUsers, conversions, eventCount, keyEvents, screenPageViews. Custom dimensions (customEvent:*), hostName, pagePath, sessionSource etc. are not available in realtime — use ga4_run_report for those. Rule: activeUsers cannot be combined with eventName (Google rejects the pair). Use eventCount + eventName for "which events are firing right now", activeUsers + unifiedScreenName for "which pages are people on", activeUsers + country / deviceCategory for who they are. Next: traffic spike → ga4_run_report with today as the range for context

ga4_list_accounts

ChatGPT
[READ] List all GA4 accounts accessible by the authenticated user

ga4_list_annotations

ChatGPT
[READ] List the annotations GA4 shows on report charts ("Deployed new checkout", "Tracking broken 3–5 May"), sorted by date. Pass startDate/endDate to keep only notes touching that window — use it to explain a spike or drop. Annotations Google creates itself (systemGenerated: true) are read-only. Dates are in the property's time zone. Uses the GA4 Admin API v1alpha (reportingDataAnnotations), which Google may change without notice.

ga4_list_conversion_events

ChatGPT
[READ] List the key events (formerly "conversions") of a GA4 property, with counting method and default value.

ga4_list_custom_dimensions

ChatGPT
[READ] List all custom dimensions for a GA4 property

ga4_list_custom_metrics

ChatGPT
[READ] List all custom metrics for a GA4 property

ga4_list_data_streams

ChatGPT
[READ] List all data streams for a GA4 property

ga4_list_properties

ChatGPT
[READ] List GA4 properties. Without accountId: every property this connection can access, across all accounts (with its account). With accountId: that account's properties including timeZone and currencyCode. Returns all pages.

ga4_run_pivot_report

ChatGPT
[READ] Run a pivot table report in GA4. Accepts optional dimensionFilter/metricFilter (same FilterExpression shape as ga4_run_report) to scope rows server-side, e.g. a single page. Each pivot takes limit, orderBys (set it for top-N) and metricAggregations (["TOTAL"] → aggregates); pivots without a limit share a ~250-cell budget. fetched.pivots shows returned vs total values per pivot; read warnings for thresholded/sampled data.

ga4_run_report

ChatGPT
[READ] Run a custom GA4 report with dimensions and metrics — this IS the generic GA4 Data API runReport: any dimension/metric name the Data API knows is accepted. Rows & order: returns at most 250 rows unless you pass limit (max 100000) — fetched.hasMore/nextOffset say when there is more. For any top-N question set orderBys (e.g. [{"metricName":"keyEvents","desc":true}]), otherwise the limit keeps GA4's default order; for a date series use [{"dimensionName":"date"}]. metricAggregations: ["TOTAL"] adds totals over all matching rows. Read warnings — GA4 flags thresholded, sampled or "(other)"-folded data there. Dates: startDate may go back to 2015-08-14 (aggregated reports are not limited by data retention); relative tokens (yesterday, 28daysAgo) resolve in the property's time zone (metadata.timeZone). Parallel-safe: if a user request needs multiple reports, call this tool in parallel — each call is independent. For 3+ similar reports on the same property, prefer ga4_batch_run_reports (one round-trip instead of N). Server-side filtering (dimensionFilter/metricFilter): to get data for a SUBSET of rows — e.g. a breakdown for ONE URL — pass a dimensionFilter so GA4 filters BEFORE the row limit, instead of downloading the whole table and filtering yourself. Common fields: pagePath, pageLocation, sessionSource, sessionMedium, deviceCategory, country. Example (one article, split by source + device): dimensions ["sessionSource","deviceCategory"], metrics ["sessions","screenPageViews"], dimensionFilter {"filter":{"fieldName":"pagePath","stringFilter":{"matchType":"EXACT","value":"/blog/my-article"}}}. Custom event queries: combine dimension eventName with metrics eventCount / totalUsers / keyEvents, and narrow to one event with a dimensionFilter on eventName. Event parameters registered as custom definitions are addressed as customEvent:<parameter_name> (event-scoped) or customUser:<name> (user-scoped) — discover what exists with ga4_list_custom_dimensions / ga4_list_custom_metrics. Next: landing pages with traffic drops → ga4_compare_periods for confirmation; conversion pages → psi_analyze for CWV baseline; top queries path → gsc_search_analytics for the same page

ga4_update_annotation

ChatGPT
[WRITE] Change a GA4 annotation's title, description, color or dates. Annotations Google creates itself (systemGenerated: true) are read-only. Dates are in the property's time zone. Uses the GA4 Admin API v1alpha (reportingDataAnnotations), which Google may change without notice.

ga4_update_conversion_event

ChatGPT
[WRITE] Change a GA4 key event's counting method and/or default value.

ga4_update_custom_dimension

ChatGPT
[WRITE] Change a GA4 custom dimension's display name, description or ads-personalization setting. Find it by definitionName or parameterName (+ scope when the name is used twice); the parameter and scope cannot change.

ga4_update_custom_metric

ChatGPT
[WRITE] Change a GA4 custom metric's display name, description, measurement unit or restricted metric type. Find it by definitionName or parameterName; the parameter cannot change.

ga4_update_data_redaction

ChatGPT
[WRITE] Change data redaction on a GA4 web stream: emailRedactionEnabled strips values that look like email addresses from event parameters and user properties; queryParameterRedactionEnabled removes the listed URL query parameters (queryParameterKeys, case-insensitive) from page URLs before GA4 stores them. Pass only the fields to change. queryParameterKeys replaces the whole list. Returns the previous settings. Web streams only; needs the Editor role. Uses the GA4 Admin API v1alpha.

ga4_update_data_retention

ChatGPT
[WRITE] Change how long a GA4 property keeps event-level and user-level data. A shorter retention removes older data from explorations; standard reports are not affected. Returns the previous settings.

ga4_update_data_stream

ChatGPT
[WRITE] Rename a GA4 data stream.

ga4_update_enhanced_measurement

ChatGPT
[WRITE] Change the enhanced measurement settings of a GA4 web stream: the master switch (streamEnabled) and each automatic event — page views on browser-history changes (pageChangesEnabled), scrolls, outbound clicks, site search (with searchQueryParameter / uriQueryParameter), form interactions, video engagement, file downloads. Pass only the fields to change; the rest stay as they are. Returns the previous settings. Web streams only; needs the Editor role. Uses the GA4 Admin API v1alpha.

ga4_update_google_signals

ChatGPT
[WRITE] Turn Google signals on or off for a GA4 property (enabled: true/false). Google signals adds data from users signed in to Google to cross-device reports and remarketing audiences; privacy-sensitive sites usually keep it off. Turning it on requires the property's terms consent, which only the GA4 UI can give. Returns the previous setting. Needs the Editor role on the property. Uses the GA4 Admin API v1alpha.

ga4_update_property

ChatGPT
[WRITE] Change a GA4 property's display name, time zone or currency. Pass at least one of them.

google_indexing_batch

ChatGPT
[WRITE] Notify Google about 1–100 URLs in one call (same notification type for all). Runs the individual urlNotifications.publish requests in parallel and aggregates per-URL results. Each URL consumes 1 of the 200 daily quota. Metrifyr auto-trims the batch to the remaining quota — if you ask for more URLs than quota allows, the overflow shows up in the overflow field (not silently dropped). Inputs: urls (1–100 https URLs), type = URL_UPDATED (default) or URL_DELETED. Response: { submitted, succeeded, failed, overflow, quota, results[] }. ALLOWED CONTENT ONLY: Google permits the Indexing API solely for pages with JobPosting or BroadcastEvent (livestream VideoObject) structured data. Submitting other pages violates Google's Indexing API guidelines and can get Metrifyr's access revoked for every user — do not use it for articles, product or landing pages. Before submitting, confirm the page type with the user (schema_validate shows its markup). For any other page use a sitemap plus Search Console's "Request indexing", and indexnow_* for Bing, Yandex and Seznam.cz. Daily limit 200 URLs. Next: spread large jobs across days if >200 URLs (daily quota); parallel to indexnow_submit_from_sitemap for full engine coverage; after 30–60 min spot-check a few URLs with gsc_inspect_url

google_indexing_from_sitemap

ChatGPT
[WRITE] Fetch an XML sitemap, optionally filter by lastmod, and submit URLs to Google Indexing API respecting the 200/day quota. Inputs: sitemapUrl, type (URL_UPDATED default), lastmodSince? (ISO date — only submit URLs changed on/after this), maxSubmissions? (cap), dryRun?. Response: { urlsInSitemap, filteredByLastmod, plannedSubmissions, quotaBefore, quotaRemainingAfter, submitted, overflow, results[] }. Behaviour: - Follows <sitemapindex> recursively up to depth 10. - Drops URLs with <lastmod> older than lastmodSince (URLs without <lastmod> pass through). - Deduplicates. - Trims to min(remainingQuota, maxSubmissions ?? remainingQuota). Anything over that shows up as overflow. - dryRun=true returns the plan without submitting. Quality bar: for recurring runs always pass lastmodSince = last run time, otherwise you burn the daily quota republishing unchanged pages. Use dryRun first on a new sitemap to see the shape of the job. ALLOWED CONTENT ONLY: Google permits the Indexing API solely for pages with JobPosting or BroadcastEvent (livestream VideoObject) structured data. Submitting other pages violates Google's Indexing API guidelines and can get Metrifyr's access revoked for every user — do not use it for articles, product or landing pages. Before submitting, confirm the page type with the user (schema_validate shows its markup). For any other page use a sitemap plus Search Console's "Request indexing", and indexnow_* for Bing, Yandex and Seznam.cz. Daily limit 200 URLs — large sitemaps will span multiple days. Next: overflow > 0 → re-run tomorrow after UTC 00:00 reset; large sitemap → split across days with lastmodSince; parallel to indexnow_submit_from_sitemap for Bing/Yandex/Seznam coverage; spot-check a URL with google_indexing_status + gsc_inspect_url

google_indexing_publish

ChatGPT
[WRITE] Notify Google that a single URL was updated or deleted so it can be re-crawled faster. Uses indexing.googleapis.com/v3/urlNotifications:publish. Requires the indexing:write OAuth scope. Inputs: url (https), type = URL_UPDATED (default) or URL_DELETED. Response: { url, type, ok, notifyTime, quota }. Quota: each successful call consumes 1 of the 200 daily quota. Metrifyr persists every submission so google_indexing_status can show you the history, and google_indexing_from_sitemap respects the remaining budget automatically. Common errors: - 403 + "must own the domain" → the authenticated Google account does not own the domain in Search Console. Add ownership first. - 403 + "not enabled on Metrifyr's side" → Metrifyr's own Google Cloud project has the Indexing API switched off. Nothing for the user to fix; do not send them to Search Console. - 429 → daily quota (200/day) exhausted. - 400 → malformed URL or URL not on a verified domain. ALLOWED CONTENT ONLY: Google permits the Indexing API solely for pages with JobPosting or BroadcastEvent (livestream VideoObject) structured data. Submitting other pages violates Google's Indexing API guidelines and can get Metrifyr's access revoked for every user — do not use it for articles, product or landing pages. Before submitting, confirm the page type with the user (schema_validate shows its markup). For any other page use a sitemap plus Search Console's "Request indexing", and indexnow_* for Bing, Yandex and Seznam.cz. Daily limit 200 URLs. Next: after 30–60 min call gsc_inspect_url to confirm indexing state; if batch-submitting >1 URL use google_indexing_batch (up to 100); parallel to indexnow_submit for Bing/Yandex/Seznam coverage (Google is not in IndexNow)

google_indexing_status

ChatGPT
[READ] Look up when a URL was last notified to Google Indexing API. Calls urlNotifications.getMetadata — does NOT consume any daily quota. Also returns the local Metrifyr submission history for the same URL so you can see both Google's view and what this workspace has pushed. Inputs: url (https). Response: { googleLatestUpdate?, googleLatestRemove?, localSubmissions: { count, recentLimit, recent[] } }. count is the total number of Metrifyr-recorded submissions ever for this URL; recent is the newest-first list of up to recentLimit (currently 10) submissions with { type, submittedAt, responseCode } so you can see the actual retry / update history, not just an aggregate. If Google returns 404 the URL has never been notified — googleLatestUpdate is absent and googleLookupError explains why. Next: never-notified (404) → google_indexing_publish to push it now; stale notifyTime + content changed → google_indexing_publish (URL_UPDATED); page removed → google_indexing_publish (URL_DELETED) then confirm via this tool

google_search_status

ChatGPT
[READ] Google's own record of what changed in Search: core updates, spam and Discover updates, and crawling / indexing / serving outages, with exact rollout start and end dates, from the public Google Search Status Dashboard. Call it first when clicks or impressions moved and nobody changed the site — a drop that starts on the first day of a core update is the update, not your edits. Default window: the last 90 days; the feed holds about 12 months. Filter by product (ranking / indexing / crawling / serving), kind (core_update, spam_update, discover_update, other_update, disruption) or ongoingOnly. Needs no Google permission. traffic_drop_diagnose already includes the incidents that overlap its windows.

gsc_batch_search_analytics

ChatGPT
[READ] Run up to 10 Search Console search-analytics queries in ONE call. Use this instead of firing many gsc_search_analytics calls when a single answer needs several date ranges, dimension sets, or filters for the same property — it runs them concurrently server-side (max 4 queries in flight — up to 8 Search Console calls with their property-totals queries — to respect the ~25 calls/sec GSC quota) and returns every result together. Each query returns its own rows + summary (totalClicks, totalImpressions, avgCtr, avgPosition) — for query/page/country/device breakdowns the summary is the property total from an extra no-dimension query (summary.source: "property-total"), not the row sum. rowLimit defaults to 250 per query (date-only queries return the whole window); check possiblyTruncated. Partial-failure safe: if one query fails the others still return — the failed entry carries an error string instead of rows, so check failedCount before trusting totals.

gsc_compare_periods

ChatGPT
[READ] Compare Search Console metrics between two time periods in ONE call — clicks, impressions, CTR, and position with per-row deltas. Use this instead of chaining two gsc_search_analytics calls and joining the results by hand (a frequent source of off-by-one date windows and mismatched join keys). Period semantics: - Preset period values ("day", "week", "month", "quarter", "year") auto-derive the previous window of equal length immediately preceding the current one. Preset windows end 3 days ago because GSC finalized data lags ~2-3 days — the exact windows used are echoed back in dateRanges. - Custom mode: pass customCurrentStart/End AND customPreviousStart/End explicitly — nothing is auto-shifted. Reading the output: - summary always compares site-level totals: with dimensions they come from a separate no-dimension query per window (same type, filters and dataState — summary.source: "property-total"), because a query/page breakdown misses anonymized queries and the long tail. - With dimensions, comparison.rows holds per-row diffs joined on the dimension values, sorted by biggest absolute clicks change; rows only present in one period are tagged status: "new" / "lost". - Position change is current − previous, so negative = improved (moved up in rankings). - Check fetched.possiblyTruncated before claiming full coverage — it flags when either period hit rowLimit. Next: biggest losing rows → gsc_search_analytics with a page/query filter for detail; position drops on money pages → psi_analyze + gsc_inspect_url; query-level losses → keyword_cannibalization to rule out internal competition

gsc_coverage_audit

ChatGPT
[READ] Bulk index-coverage audit: inspects a set of URLs and returns a grouped diagnosis (indexed / crawled-not-indexed / discovered-not-indexed / noindex / robots-blocked / canonical mismatch / fetch errors), each with a count, sample URLs, and a specific fix. Explicitly flags URLs where Google picked a different canonical than the page declares. This is an async tool: returns a jobId immediately. Poll job_status({ jobId }) for results (pass wait: true to block). Quota cost — read before calling. Each inspected URL consumes ONE call of Google's 2000/day-per-property URL Inspection quota, and the API is single-URL at ~6s per call. A default run costs 50 of those 2000 calls and takes ~1 minute. Daily budget guard. The audit reserves the URLs it will inspect against a per-property 2000/day budget that is shared with gsc_inspect_url and tracked across calls. If the day's remaining budget is short it inspects only what fits and defers the rest (reported in quota.usedToday/remainingToday and a deferral note) — re-run tomorrow or with fewer URLs. So repeated audits cannot exhaust a property's daily quota. Cap. Inspects at most maxUrls URLs (default 50, hard max 100) — a deliberate sample, NOT full site coverage. When a sitemap yields more URLs than the cap, the result reports { totalFound, inspected, skipped, capped: true } and you MUST present it as a sample of N URLs, never as a sitewide verdict. Input: siteUrl plus EITHER urls (explicit list) OR sitemapUrl (candidates pulled from a sitemap or sitemap index) — one, not both. With neither, the audit falls back to the sitemap registered for the property in Search Console (preferring a sitemap index) and says which one it picked. Example: { "siteUrl": "sc-domain:example.com", "sitemapUrl": "https://example.com/sitemap.xml", "maxUrls": 50 } Read-only: nothing is changed in your site, Google or any other account. The background job only holds the result until job_status returns it, and expires on its own. Next: canonical_mismatch group → gsc_inspect_url on a sample to confirm, then fix rel=canonical / internal links; crawled_not_indexed group → content quality problem, not config: content_decay_scan / content_opportunity_finder; discovered_not_indexed group → crawl budget: google_indexing_batch or indexnow_submit plus internal linking; server_error / soft_404 groups → psi_analyze + url_full_report on a sample URL

gsc_delete_sitemap

ChatGPT
[WRITE] Delete a sitemap from Google Search Console

gsc_get_site

ChatGPT
[READ] Get information about a specific site in Google Search Console

gsc_inspect_url

ChatGPT
[READ] Inspect a URL's index status in Google Search Console. Returns indexing state, coverage details, crawl info, mobile usability, and rich results status. Quota: 2,000 requests/day per property. Latency: ~6s per call (Google's URL Inspection API is single-URL, not batched). For sitewide audits, use gsc_search_analytics first to narrow which URLs are worth inspecting — do not loop over more than ~5 URLs without explicit user intent. Next: coverage issues → seo_audit on the page; mobile usability → psi_analyze with strategy=mobile

gsc_list_sitemaps

ChatGPT
[READ] List all sitemaps submitted for a site in Google Search Console. WARNING — `contents[].indexed` is unreliable. The Google Search Console API frequently reports indexed: 0 even on healthy sites where the pages are in fact indexed. This is a known, long-standing quirk of the GSC sitemap counter, not a real signal. Never report it as indexing status without first cross-checking via gsc_inspect_url on 2–4 sample submitted URLs. Ground truth = the gsc_inspect_url verdict, not these sitemap counters. Use this tool for: sitemap presence, lastSubmitted / lastDownloaded freshness, parse errors / warnings. Do NOT use it for an indexing-status claim. Next: verify index coverage → gsc_inspect_url on 2-4 sample URLs from the sitemap; stale sitemap (no recent lastSubmitted) → gsc_submit_sitemap; missing URLs → seo_audit

gsc_list_sites

ChatGPT
[READ] List all sites you have access to in Google Search Console Next: follow up with gsc_search_analytics for any selected site

gsc_performance_dashboard

ChatGPT
[READ] Interactive Google Search Console performance dashboard: the same metrics as gsc_search_analytics (clicks, impressions, CTR, average position) returned with an inline visual UI — KPI tiles plus a clicks/impressions time-series chart, or a sortable query/page table — that renders directly in the conversation on MCP Apps-capable clients such as Claude. Use this when the user wants to see or visualize their Search Console performance, asks for a dashboard / chart / graph, or wants to explore trends interactively. For pure data extraction into your own downstream analysis, gsc_search_analytics is lighter. Params: siteUrl (required); days (7–180, default 90, window ends 3 days ago for GSC's data lag); dimension ('date' = time-series [default], 'query' = top queries, 'page' = top pages; query/page cap at 100 rows). Output: the inline widget gets every row; the JSON text stays compact — rounded numbers as columns/rows tuples, ranked views cut to the top 25 rows (truncated says so). Clients without MCP Apps support read that same text (graceful fallback); for the complete dataset use gsc_search_analytics.

gsc_search_analytics

ChatGPT
[READ] Query search analytics data from Google Search Console (impressions, clicks, CTR, position). Parallel-safe: if a user request needs data across multiple dimensions, date ranges, or filters, call this tool in parallel — each call is independent. Rate-limit caveat: GSC enforces a per-property quota (~1200 calls/min/user, ~25 calls/sec). For 5+ parallel calls on the same property, batch dimensions in one request rather than fanning out. If you see 429 errors, drop concurrency to 2–3. Response size: rowLimit defaults to 250 rows (date-only queries return the whole window); raise it (max 25000) or page with startRow = nextStartRow when possiblyTruncated is true. ctr is a fraction (0.034 = 3.4 %) rounded to 4 decimals, position to 2. Aggregation guidance — read before answering "how is site X doing": - For property-level totals (trend / overview questions) leave aggregationType unset and use no dimensions or the date dimension only — that matches the GSC UI. Pull at least 90 days and report WoW or MoM deltas of total clicks and impressions. - Use the top-level summary block instead of re-summing rows. When you break down by query/page/country/device, summary comes from a separate no-dimension query (summary.source: "property-total") because the rows miss anonymized queries and the long tail; summary.rowsSum and summary.coverage show how much of the total the rows cover. - by-date or by-page mean position is a TRAP: a single outlier page at pos 28 skews the daily/weekly average. Mean position is only meaningful for property totals and on windows of 7 days or more. Never report a single day's mean position as a trend signal. - A single 28-day average hides accelerating or decelerating trends — always include a WoW or MoM delta when answering an overview question. Next: losing pages → psi_analyze on top 3; positions 8–20 → striking_distance_optimizer / content_opportunity_finder; low CTR on >2k impressions → title/meta rewrite; high impressions + no clicks → gsc_inspect_url to check indexing

gsc_submit_sitemap

ChatGPT
[WRITE] Submit a sitemap to Google Search Console

gtm_audit_container

ChatGPT
[READ] Audit a GTM container for deprecated UA tags, missing Consent Mode v2, and naming conventions

gtm_get_container

ChatGPT
[READ] Get details of a specific GTM container

gtm_get_tag

ChatGPT
[READ] Get details of a specific GTM tag

gtm_list_accounts

ChatGPT
[READ] List all Google Tag Manager accounts accessible by the authenticated user

gtm_list_containers

ChatGPT
[READ] List all containers under a specific GTM account

gtm_list_tags

ChatGPT
[READ] List all tags in a GTM workspace

gtm_list_triggers

ChatGPT
[READ] List all triggers in a GTM workspace

gtm_list_variables

ChatGPT
[READ] List all variables in a GTM workspace

gtm_list_versions

ChatGPT
[READ] List all versions of a GTM container

gtm_list_workspaces

ChatGPT
[READ] List all workspaces in a GTM container. Use this to find the active workspace path before calling tag/trigger/variable tools.

indexnow_generate_key

ChatGPT
[READ] Generate a fresh IndexNow API key + step-by-step setup instructions for a domain. Returns a 32-character hex key plus the suggested keyLocation URL (https://{host}/{key}.txt). The caller still has to publish the key file on the domain before indexnow_submit will succeed — this tool does not upload anything. Input: host — domain without protocol (e.g. "www.example.com"). Output: { key, keyLocation, fileContents, instructions }. Next action: host the file, then call indexnow_submit or indexnow_submit_from_sitemap with the same key + keyLocation. Next: user hosts the key file → indexnow_submit_from_sitemap with the same key + keyLocation; single-URL push → indexnow_submit

indexnow_submit

ChatGPT
[WRITE] Submit URLs to IndexNow — notifies Bing, Yandex, Seznam.cz, Naver, and Yep in one request. Google is NOT in IndexNow; use Google-native indexing flows separately. Inputs: host, key, keyLocation, urls[] (1–10000, all on the same host as host). Response codes (mapped to the `message` field): - 200 OK — accepted - 202 Accepted — queued pending key verification - 403 — key file not reachable at keyLocation - 422 — URL host mismatch - 429 — rate limited Quality bar: submit only URLs that genuinely changed — abuse triggers 429 and may get the key de-listed. Next: 403 → re-check keyLocation is publicly fetchable and returns the key; 422 → filter URLs so they all match host before retrying; 429 → back off; do not re-submit in a loop; after 5–30 min → gsc_inspect_url for Google coverage (Google is not in IndexNow)

indexnow_submit_from_sitemap

ChatGPT
[WRITE] Fetch an XML sitemap (or sitemap index), extract URLs, and submit them to IndexNow. - Follows <sitemapindex> recursively up to depth 10. - Optional lastmodSince filters to URLs whose <lastmod> is >= the ISO date. URLs without <lastmod> pass through (fallback). - Deduplicates URLs before submit. - Batches >10000 URLs into multiple IndexNow calls (one batch = one HTTP POST). - Host is inferred from the sitemap URLs unless explicitly provided; cross-host URLs in a sitemap are skipped (reported in skippedDifferentHost). Inputs: sitemapUrl, key, keyLocation, optional lastmodSince, optional host. Next: recurring publishes → pass lastmodSince to submit only changed URLs; large sitemap (>10k URLs) → batches are automatic; check each batch status; any non-OK batch → stop and diagnose before resubmitting

job_status

ChatGPT
[READ] Check the status of an async job. Returns the job status and result when completed. Async tools that return jobId: psi_analyze, seo_audit, url_full_report, gsc_coverage_audit Status values: - pending: Job is waiting in queue - running: Job is being processed - completed: Job finished, result is available - failed: Job failed, error message is available - cancelled: Job was cancelled - not_retained: no job with this id is held any more (results are kept one hour). Terminal — stop polling and re-submit if you still need the result. Two ways to use this tool — pick based on what else you have to do: 1. DEFAULT (no wait): returns immediately with the current status. Use when you submitted multiple jobs in parallel, or when you have other work to do between checks. Re-call every 3–5s; polling faster wastes rate-limit budget and rarely uncovers a result sooner. 2. wait: true: server holds the response open until the job finishes, or up to timeoutSeconds (default 25, max 28). Returns as soon as the job is done. Use when you submitted ONE job and have nothing else to do — saves 5–10 redundant polling round-trips. Don't combine wait: true with a tight polling loop — pick one mode. Async jobs typically take 5–30s (PSI ~10s, seo_audit ~20–30s). Examples: - Quick check: { "jobId": "abc123xyz" } - Wait until done: { "jobId": "abc123xyz", "wait": true }

keyword_cannibalization

ChatGPT
[READ] Detect keyword cannibalization: queries where two or more pages of the same site compete in Google Search. Runs one [query, page] Search Console query and does the group-by server-side, so you don't have to join 25k rows by hand. Flags a query when a second page holds at least minPageShare (default 10%) of its impressions. Results are ranked by impressionsAtStake — the impressions NOT going to the primary page — and each carries a suggestedAction: - consolidate — both pages earn clicks at similar positions (same intent): merge + 301 - canonicalize — the competitor only splits impressions without clicks: canonical/301 to the primary - differentiate — pages rank far apart with separate clicks (likely different intents): re-target the secondary The action is a metrics-only heuristic — inspect the actual pages before acting. Default window: 28 days ending 3 days ago (echoed back in dateRange). Next: inspect both page URLs before recommending a merge or redirect; consolidate/canonicalize candidates → gsc_inspect_url to check canonicals; differentiate candidates → content_opportunity_finder for the secondary intent

keyword_research

ChatGPT
[READ] Research up to 10 keywords in ONE call: Bing Webmaster monthly volume + related terms, Google Autocomplete long-tail suggestions (optional), your own Search Console clicks / impressions / position for each term (when siteUrl is given), and an optional Google Trends direction. Every row gets an opportunity read — "gap: demand exists, you do not rank", "striking distance", "winning — defend". Use it instead of calling bing_keyword_stats, keyword_suggest, trends_interest_over_time and gsc_search_analytics one after another — the same data, one call, and the volumes are market-aware (country/language, e.g. jp / ja-JP). Pass keywords for a list you already have, or seed to let Autocomplete propose the list. Volumes come from Bing (the only free official source, ~10× smaller than Google); googleVolumeEstimate is a rough ×10 proxy, not a measurement. Trends is throttled by Google — leave includeTrends off unless you need the direction.

keyword_suggest

ChatGPT
[READ] Discover long-tail keyword suggestions for a seed term by combining Brave Suggest and/or Google Autocomplete. Use this when you need ideas (not search volumes!) — typical inputs: - A topic seed like "pixel game" or "next.js streaming" - An expansion mode: "alphabet" (appends a–z to the seed) or "wh-questions" (prepends how/what/why/etc.) for ~30× more suggestions per call Suggestions that appear in both Brave and Google get the in_both: true flag — that's the strongest validation that real users search the phrase, since two independent indexes agree. Returns popularity-ordered phrases, not volumes. Pair with bing_keyword_stats (when available) for actual numbers. Brave Suggest only fires when BRAVE_API_KEY is configured on the MCP server. Google Autocomplete is always available.

monitoring_disable

ChatGPT
[WRITE] Disable scheduled monitoring for a site (all checks, or specific ones via "checks"). History and past alerts are kept. Example: { "siteUrl": "https://example.com" }

monitoring_enable

ChatGPT
[WRITE] Enable daily scheduled monitoring for a site. Metrifyr will check the site every day and alert you (email + alerts_list) when something degrades. Available checks: - gsc_analytics: clicks/impressions/position week-over-week anomaly detection (default threshold: 25% drop) - sitemap_health: sitemap processing errors - ga4_sessions: sessions vs the same day a week earlier, on complete days in the property's time zone (requires ga4PropertyId) - rank_tracker: daily positions of keywords tracked via rank_tracker_add (needs tracked keywords) - cwv: Core Web Vitals (LCP/INP/CLS) for URLs tracked via cwv_tracker_add — alerts on rating-band regressions - clarity: daily Microsoft Clarity snapshot (sessions, rage/dead clicks, quick-backs, script errors, scroll depth) — needs a Clarity connection on this key; alerts on session drops and frustration spikes, and feeds clarity_history Default when "checks" is omitted: gsc_analytics + sitemap_health (+ ga4_sessions when ga4PropertyId is provided, + clarity when Clarity is connected). Re-arming: checks that were switched off automatically after repeated failures (monitoring_status shows them with disabledReason) come back with { "siteUrl": ..., "rearm": true } — exactly those checks, with their GA4 property and threshold kept. When "checks" is omitted and the site has such checks, rearm happens automatically. Fix the cause in lastError first. Existing thresholds and GA4 properties are only overwritten when you pass a new value. Access is verified before anything is saved: a siteUrl that is not one of this key's Search Console properties is rejected with the property id the account does have (e.g. sc-domain:example.com), and an unreadable ga4PropertyId is rejected with matching properties it can read. Examples: - { "siteUrl": "https://example.com" } - { "siteUrl": "sc-domain:example.com", "ga4PropertyId": "properties/123456789", "thresholdPercent": 30 } - { "siteUrl": "sc-domain:example.com", "rearm": true }

monitoring_status

ChatGPT
[READ] List configured scheduled checks with their latest values and run times. Optionally filter by site.

portfolio_pulse

ChatGPT
[READ] How every Search Console site and every GA4 property this Google account can see is doing — this period against the previous one, biggest change first — in ONE call. Use it for "which of my sites moved this week?" instead of calling gsc_compare_periods, ga4_compare_periods or site_workspace_bootstrap once per site. Returns searchConsole[] (clicks, impressions, CTR, average position, current vs previous, with absolute and percent change for clicks and impressions) and analytics[] (sessions and active users, same shape). The two lists are separate: Search Console sites are not matched to GA4 properties. Percent change is null when the previous value was 0. Windows: days (7, 28 or 90) complete days vs the N days before them. Search Console windows end 3 days ago because its data lags; GA4 windows end yesterday in each property's time zone. Both are echoed in period. Pick the site worth a closer look, then drill in with gsc_compare_periods, ga4_compare_periods or traffic_drop_diagnose. A site or property whose call fails comes back in skipped with a short reason; one failure never fails the call. If Google reports a quota or rate limit, no further requests are started and the remaining ones are listed as skipped. A source the key lacks permission for, or whose tool group is switched off for this connection, is not read and is named in unavailableSources. At most 100 sites / properties per source are queried; omitted counts the ones not returned.

psi_analyze

ChatGPT
[READ] Analyze a URL with PageSpeed Insights. Returns a job ID - use job_status to get results. This is an async tool: Returns immediately with a jobId (typically <10ms). The actual analysis runs in the background and usually takes 10–60s (heavy pages longer; upstream errors are retried once). Two patterns for collecting results: - Single URL, nothing else to do: submit psi_analyze, then call job_status({ jobId, wait: true }) — one round-trip, no polling. - Multiple URLs: submit psi_analyze for each in parallel (each returns its own jobId immediately), then poll job_status for each. Don't submit them serially — parallel submission cuts wall-clock time by N×. Use checkMode for quick pass/fail evaluation against thresholds. Each Core Web Vital has a source: field (CrUX real users; fieldDataScope url or origin), lab (this Lighthouse run) or none. INP exists only as field data — without it INP is null and checkMode reports it as unavailable, not passed. Example usage: - Analyze mobile performance: { "url": "https://example.com" } - Analyze desktop: { "url": "https://example.com", "strategy": "desktop" } - Specific categories: { "url": "https://example.com", "categories": ["performance", "seo"] } - Quick health check: { "url": "https://example.com", "checkMode": true } Read-only: nothing is changed in your site, Google or any other account. The background job only holds the result until job_status returns it, and expires on its own. Next: LCP > 2.5s → surface the LCP element and its cause; CLS > 0.1 → list the shifting elements; INP > 200ms → inspect long tasks / JS work; compare URLs → run psi_analyze on each and present a diff table

rank_tracker_add

ChatGPT
[WRITE] Start tracking keyword positions for a site. Positions are snapshotted daily from Search Console data (only the tracked queries are requested, so low-traffic keywords on big sites are not missed) and alerts fire when a keyword falls out of the top 10, loses 5+ places, or — having ranked in the top 20 — loses all impressions. Positions are GSC average positions (impression-weighted), not deterministic SERP ranks. Limit: 50 keywords per site. The siteUrl must be one of this key's Search Console properties — otherwise the call is rejected and names the property the account does have (e.g. sc-domain:example.com). Tip: pick keywords from gsc_search_analytics results — queries at positions 8-20 with impressions are the best candidates to watch. Example: { "siteUrl": "https://example.com", "keywords": ["seo tools", "rank tracker"] }

rank_tracker_history

ChatGPT
[READ] Position history for tracked keywords (time series, sparkline-friendly). Positions are GSC average positions; lower is better. A day on which a tracked keyword had no impressions is a data point with position null and impressions 0 (lost visibility), not a gap. Examples: - All keywords, last 30 days: { "siteUrl": "https://example.com" } - One keyword, last 90 days: { "siteUrl": "https://example.com", "keyword": "seo tools", "days": 90 }

rank_tracker_remove

ChatGPT
[WRITE] Stop tracking keywords for a site. Omit "keywords" to remove all tracked keywords for the site (this also disables the daily snapshot check). Position history is kept. Example: { "siteUrl": "https://example.com", "keywords": ["seo tools"] }

schema_validate

ChatGPT
[READ] Validate Schema.org JSON-LD structured data on a page. Extracts all <script type="application/ld+json"> blocks, parses each as JSON, and checks required + recommended fields per Schema.org @type (Article, Product, Organization, Event, Recipe, BreadcrumbList, FAQPage, HowTo, VideoObject, Review, Person, Book, JobPosting, LocalBusiness, SoftwareApplication, Course, WebSite, WebPage). Inputs (exactly one): - url — page URL to fetch - html — raw HTML string (useful for gated or local pages) Output: per-block report with @type, parsed data, and list of errors + warnings. Scope: validates structure + required-field presence. Does NOT deeply validate field values (e.g. whether a date string is a valid ISO date, or whether an offer's price currency is a valid ISO 4217 code). For end-to-end rich-results validation, use Google's Rich Results Test UI (https://search.google.com/test/rich-results) — this tool is the fast pre-flight check. Next: errors present → fix required fields before rich results can render; warnings only → add recommended fields for richer SERP appearance; no JSON-LD found → start with Organization + WebSite schema on the homepage

seo_audit

ChatGPT
[READ] Comprehensive SEO audit combining PageSpeed Insights, Search Console data, and optional trend analysis. Returns a job ID - use job_status to get results. This is an async tool: Returns immediately with a jobId. Use job_status({ jobId }) to check progress and get results. Returns when completed: - PSI: Performance scores, Core Web Vitals, top opportunities (mobile and desktop — each can fail on its own) - GSC (if siteUrl provided): full clicks/impressions/CTR and impression-weighted position from a no-dimension query, plus the top 10 queries. For a page URL the data is filtered to that page; for a homepage URL it covers the whole property. Window: days ending 3 days ago (GSC data lag), echoed in gsc.period - Trends: Interest over time for specified keywords (if keywords provided) - Recommendations: Top issues and suggested improvements Each section fails independently: a failed section carries error with Google's message and the fix, and errors[] lists them — the rest of the audit still returns. Example usage: - Basic PSI audit: { "url": "https://example.com" } - Full audit: { "url": "https://example.com", "siteUrl": "sc-domain:example.com", "keywords": ["example brand"] } Read-only: nothing is changed in your site, Google or any other account. The background job only holds the result until job_status returns it, and expires on its own. Next: blocking issues → fix list, then re-run seo_audit; CWV failures → psi_analyze for deeper field data; content thinness → content_opportunity_finder

seo_post_deploy_publish

ChatGPT
[WRITE] One-call "close the loop after deploy" tool — submits the sitemap to Google Search Console, then optionally pushes a list of newly-published URLs through the Google Indexing API and through IndexNow (Bing, Yandex, Seznam.cz, Naver, Yep). Inputs: siteUrl (GSC property), sitemapUrl (HTTPS), optional newUrls (up to 50), optional indexnow: { key, keyLocation, host? }. Steps run (always returned, marked status `ok`/`skipped`/`failed`): 1. gsc_submit_sitemap — PUTs the sitemap. Requires the searchconsole:write scope on this API key. 2. google_indexing_batch — runs only if newUrls is provided AND this API key has the indexing:write scope. Respects the shared 200/day Google Indexing quota (UTC reset). Tries each URL even if some fail. 3. indexnow_submit — runs only if newUrls and indexnow params are provided. No OAuth, but the IndexNow key file must already be hosted at keyLocation. When to use: right after a CI/CD deploy that publishes new blog posts or locale variants. Avoids hand-rolling three separate tool calls. When NOT to use: for ongoing bulk indexing of an existing sitemap, prefer google_indexing_from_sitemap (smarter quota handling + lastmodSince filter). For Bing/Yandex bulk, use indexnow_submit_from_sitemap. Next: failed gsc_submit_sitemap step → check the manual GSC URL shown in the detail and re-run after fixing scopes; overflow on google_indexing_batch → schedule a follow-up google_indexing_from_sitemap for tomorrow; IndexNow 403 → re-host the key file at the reported keyLocation, then re-run

site_workspace_bootstrap

ChatGPT
[READ] Resolve everything Metrifyr knows about a domain in ONE call — the confirmed Search Console siteUrl (sc-domain vs https vs www variant, so you never guess the format again), the GA4 propertyId + measurementId (matched via web data-stream URLs, not display names; other properties streaming the same domain come back as analytics.alternates), the AdSense account + site state, configured monitoring checks, and the tracked-keyword count. Call this FIRST at the start of a session about a specific site. It replaces the usual gsc_list_sites → ga4_list_accounts → ga4_list_properties → ga4_list_data_streams → adsense_list_accounts discovery loop, and its missing list tells you exactly what is not set up yet and which tool fixes it. Sections the API key lacks scopes for are reported as unavailable rather than failing the call. nextSteps lists the proactive features this site is not using yet — daily monitoring, an email digest, rank and Core Web Vitals tracking — each as the exact call that switches it on. Offer them to the user once; do not enable anything without being asked.

striking_distance_optimizer

ChatGPT
[READ] Find striking-distance opportunities: queries ranking just off the top of page 1 (positions 4–15 by default) where a content push gives the biggest click payoff — the "money list". Runs one [query, page] Search Console query and does the filtering, uplift math, and ranking server-side. Each opportunity carries estimatedClicksAtTarget (impressions × a published organic-CTR curve at position ~3) and clickGain (estimate minus current clicks — the ranking key). The estimate is directional, not a traffic promise: real CTR varies by intent and SERP features. Rows whose query is also contested by a second page of the same site are marked cannibalized: true — fix the cannibalization first, optimizing a split query wastes the push. Default window: 28 days ending 3 days ago (echoed back in dateRange); use datePreset or explicit startDate/endDate to change it. Next: top opportunities → content_opportunity_finder to plan the content push for that query/page; cannibalized: true → keyword_cannibalization for the full competing-page breakdown, fix that first; before optimizing a page → gsc_inspect_url to confirm it is indexed with the expected canonical

traffic_drop_diagnose

ChatGPT
[READ] Diagnose a traffic drop with an explicit attribution verdict — not another report to interpret. Compares the last N days against the N before (default 28, ending 3 days ago so data is settled) and answers WHY clicks fell: - ranking-loss — position worsened - ctr-collapse — impressions held but clicks fell (AI Overviews / SERP-feature absorption is the usual suspect) - demand-decline — fewer searches for your topics - mixed / no-material-drop — with the numbers to show it The verdict is corroborated bottom-up: the top losing queries and pages each get the same signature, and the distribution is returned as evidence. The top losing pages also get a Wayback Machine change timeline (evidence.pageChanges) — the dates their content changed inside the window — so "we edited the page on the 14th" sits next to "clicks fell from the 15th". Attach a GA4 propertyId to also check whether the AI Assistant channel gained while organic fell, and to list the GA4 annotations (evidence.ga4Annotations) and GA4 configuration changes (evidence.ga4ConfigChanges, connections with GA4 admin access) from the start of the comparison until today. Chain with striking_distance_optimizer / content_decay_scan / ga4_ai_traffic_report for the fix.

url_full_report

ChatGPT
[READ] Full health check of a single URL in ONE call — runs PageSpeed Insights (mobile CWV), Search Console top queries for the page, GA4 traffic by channel for the page path, and JSON-LD schema validation in parallel, then merges everything into one document with an issues highlight list. This is an async tool: returns immediately with a jobId. Use job_status({ jobId }) to get the report (typically ready in 20-40s; PSI dominates). Pass siteUrl and ga4PropertyId to get the full picture (find them via gsc_list_sites / ga4_list_properties or site_workspace_bootstrap); without them you still get PSI + schema. A bare domain siteUrl is resolved to the matching property (sc-domain: / https / www) — the submit response echoes the one used. Each section fails independently — check for an error field per section instead of assuming the whole report failed. Search Console totals are the page's full totals (a page-filtered query without dimensions, incl. anonymized queries); topQueries lists the top 25 and topQueriesClickShare says how much of the clicks they explain. Use this as the FIRST call when diagnosing "why does this page underperform?" — it replaces the manual psi_analyze + gsc_search_analytics + ga4_run_report + schema_validate sequence. Read-only: nothing is changed in your site, Google or any other account. The background job only holds the result until job_status returns it, and expires on its own.

verify_claim

ChatGPT
[READ] Verify numbers before they reach a client report. Pass up to 10 claimed figures (source, metric, window, optional single-dimension filter) and each is re-queried against the live Search Console or GA4 API. Per-claim verdicts: verified (within tolerance, default ±2%), mismatch (actual value + delta returned — fix the report), unverifiable (missing scope / bad input / API error, with the reason). Every verdict carries a provenance stamp: API, property, date range, filter. Units: ctr and engagementRate are fractions in the APIs (0.034 = 3.4 %). A percent claim (3.4) is detected and compared as 0.034 — the verdict then carries normalizedFromPercent: true, and actualValue stays a fraction (do not "correct" the report to 0.034). Rounding in the claim is allowed, and position passes within ±0.2. Use it as the last step of any reporting workflow: cheap insurance against a hallucinated number reaching a client.

Capabilities

WritesInteractive

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/metrifyr"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/metrifyr)