List all available tools and declared search-engine credentials.

List all GSC properties the authenticated account can access, with their permission levels.

Get the permission level for a specific GSC property URL.

Fetch GSC search analytics (clicks, impressions, CTR, position) for a site.

Groups results by the requested dimensions (query, page, device, country). Data has a 3-day reporting lag; the window covers the days days ending 3 days ago.

Summarise total clicks, impressions, average CTR and average position for a site.

Returns aggregate totals plus the top 10 queries by clicks over the rolling window.

Compare two consecutive equal-length windows and report delta in clicks and impressions.

Period B is the most recent days days (with a 3-day lag). Period A is the days days immediately before that. Useful for week-over-week or month-over-month trends.

Fetch GSC data grouped by both page and query simultaneously.

Useful for identifying which query drives which page and diagnosing on-page relevance issues.

Fetch GSC search analytics with full control over search_type, data_state, dimensions, and row limit.

search_type: 'web' (default), 'image', 'video', or 'news'. data_state: 'final' (default, omit to use API default) or 'all' (includes fresh unverified data). dimensions: list of 'query', 'page', 'device', 'country', 'searchAppearance'. Use when get_search_analytics defaults are not sufficient.

Detect days with statistically abnormal click volumes using z-score analysis.

A day is flagged as a spike or drop when abs(z_score) > threshold (default 2.5). Returns mean_daily_clicks, std_daily_clicks, and the list of anomalous days with their z-score. Use days=90 or more for meaningful baseline statistics.

Identify pages ranking between positions 4-15 whose CTR is below the industry benchmark for their rank.

Sorted by opportunity_score = (benchmark_ctr - actual_ctr) * impressions. High scores mean large click gains are possible with CTR optimisation (title/meta improvements).

Find queries whose clicks dropped compared to the previous equally-sized period.

Each result includes a diagnosis: 'ranking_loss' (position degraded by more than 2), 'ctr_collapse' (CTR fell more than 30%), or 'demand_decline' (impressions also fell). Note: uses date.today() without a GSC reporting lag, so the most recent 2-3 days may be incomplete.

Scan for structural SEO risks: traffic concentration and high-impression low-rank pages.

Flags 'traffic_concentration' (severity: high) when a single query drives more than 50% of all clicks (fragility indicator) and 'high_impression_low_rank' (severity: medium) when a page gets more than 5000 impressions at position > 10 (content optimisation opportunity).

List queries ranking between positions 8-15, sorted by impressions descending.

These are the best candidates for ranking improvement: close enough to page 1 that targeted content or link optimisation can move them into top positions.

Detect queries where multiple pages compete for the same ranking slot.

Uses the Herfindahl-Hirschman Index (HHI) to measure click concentration across pages. conflict_score = 1 - HHI: values near 1 mean clicks are split evenly across pages (high competition). Filters to queries with at least min_impressions total impressions to exclude noise.

Find queries that had significant clicks previously but now have 80%+ fewer clicks.

Only queries with at least 5 clicks in the previous period are included to filter noise. Note: uses date.today() without a GSC reporting lag, so the most recent 2-3 days of the current period may include incomplete data and produce false positives.

Inspect a single URL in GSC to get its indexing status, last crawl time, and canonical URL.

Returns verdict (PASS/NEUTRAL/FAIL), robotsTxtState, indexingState, pageFetchState, googleCanonical, userCanonical, and a derived category (indexed, robots_blocked, fetch_error, canonical_issue, not_indexed, unknown).

Inspect up to 10 URLs at once in GSC. Returns the same fields as inspect_url for each URL.

Inspect up to 10 URLs and return only those with indexing problems, plus a summary count by category.

Categories: indexed, not_indexed, robots_blocked, fetch_error, canonical_issue, unknown. Use batch_url_inspection if you need results for all URLs regardless of status.

Submit a single URL to the Google Indexing API for crawl notification.

url_type must be 'URL_UPDATED' (page added or changed, default) or 'URL_DELETED' (page removed). Requires a service account with Indexing API access — OAuth is not sufficient. Transient 429/5xx errors are retried automatically (up to 3 times). Credential errors and non-retryable failures propagate to the caller.

Submit multiple URLs to the Google Indexing API in HTTP batches of 100.

Returns per-URL results, total submitted/error counts, and remaining daily quota. Daily limit is 200 requests total. A quota_warning is added to the response when usage exceeds 180. url_type: 'URL_UPDATED' (default) or 'URL_DELETED'.

List all sitemaps submitted to a GSC property, with submission dates, status, and error counts.

Submit a new sitemap URL to a GSC property. If already submitted, GSC updates the existing entry.

Delete a submitted sitemap from a GSC property.

Requires the URL to end with '.xml' or contain '/sitemap' as a safety guard against accidental deletion. Removes the entry from GSC tracking only; does not delete the sitemap file.

Get details for a specific sitemap already submitted to a GSC property.

Returns content type counts (URLs, images, videos), error and warning counts, and status flags.

Fetch a sitemap and compare its URLs with pages visible in Search Analytics.

Handles both regular sitemaps () and sitemap index files (), with one level of recursion for sitemap indexes. Uses defusedxml for safe XML parsing (prevents XXE and billion-laughs attacks from untrusted external XML).

Search Analytics is not an indexation inventory: a page without search data can still be indexed. The original urls_in_gsc, urls_missing_from_gsc, missing_sample and verdict fields are retained for compatibility, but only describe Search Analytics visibility. Prefer the explicit visibility fields.

Fetch GA4 landing page performance filtered to organic traffic only.

Dates use GA4 relative format: '28daysAgo', 'today', '7daysAgo', 'yesterday', or 'YYYY-MM-DD'. Returns sessions, engaged_sessions, bounce_rate, avg_session_duration, conversions, and revenue per landing page. Pass property_id to override GA4_PROPERTY_ID for multi-property setups. hostname and country narrow results to a specific host or country.

Fetch GA4 sessions grouped by channel group, source, and medium.

Shows which traffic channels (Organic Search, Direct, Referral, etc.) drive the most sessions, engagement, conversions, and revenue. Dates use GA4 relative format: '28daysAgo', 'today', 'YYYY-MM-DD'. hostname and country narrow results.

Fetch GA4 page-level metrics: views, active users, session duration, engagement and bounce rates, conversions, and revenue.

Optionally filter to pages whose path contains page_path (substring match). Dates use GA4 relative format: '28daysAgo', 'today', '7daysAgo', 'YYYY-MM-DD'. hostname and country narrow results to a specific host or country.

Fetch active users in the last 30 minutes from the GA4 Realtime API.

Groups active users by screen name, country, and device category. Use for live traffic monitoring. No date range applies — this reflects the current moment only. hostname narrows results to a specific host (country is already a dimension, not a filter).

Fetch GA4 sessions and engagement rate broken down by device, country, and user type.

Executes a single batch request returning three reports: by device category, by country (top 20), and by new vs returning users. Useful for audience analysis. hostname and country narrow results across all three sub-reports.

Fetch GA4 conversion data: pages that generated conversions, and event counts.

Runs two reports in sequence: pages ranked by conversion count, and events ranked by event_count (optionally filtered to a specific event_name). Useful for identifying which pages and events drive goals. Dates use GA4 relative format. hostname and country narrow both reports to a specific host or country.

Compare total GSC clicks with total GA4 organic sessions to detect tracking gaps.

Fetches aggregate GSC clicks (no page dimension) and sums all organic sessions from GA4. The ratio ga4_sessions / gsc_clicks indicates tracking health:

• "no_gsc_data" : zero GSC clicks (ratio is None, nothing to compare)

• "tracking_gap" : ratio < 0.6 (GA4 records far fewer sessions than GSC clicks)

• "filter_issue" : ratio > 1.3 (GA4 records more sessions than GSC clicks)

• "healthy" : 0.6 <= ratio <= 1.3

Boundaries 0.6 and 1.3 are inclusive of the healthy range (strict < and >). GA4 is queried with limit=10000 to avoid under-counting sessions on large sites. hostname and country narrow the GA4 query to a specific host or country.

Join GSC and GA4 data at the page level and rank by opportunity score.

GSC rows are fetched with dimensions=["page"] (already aggregated per page). GA4 organic landing pages are fetched with a high limit to avoid truncation. Pages are joined on _normalize_url. Pages that appear in only one source get None for the missing fields.

opportunity_score = log10(impressions+1)10 + engagement_rate100 + log10(conversions+1)*20

engagement_rate is derived as engaged_sessions/sessions (GA4 native formula) because ga4_organic_landing_pages does not expose it directly.

Results are sorted by opportunity_score descending, truncated to limit. hostname and country narrow the GA4 query to a specific host or country.

Fetch current Core Web Vitals (LCP, INP, CLS, FCP, TTFB) for a URL from the CrUX API.

form_factor: "ALL_FORM_FACTORS" | "PHONE" | "DESKTOP" | "TABLET" Returns p75 percentile and a good/needs_improvement/poor rating per metric. If the URL has insufficient data (<1000 real users over 28 days), returns verdict=not_enough_data. Requires CRUX_API_KEY environment variable (Google API key with Chrome UX Report API enabled).

Fetch 40 weeks of Core Web Vitals history for a URL from the CrUX History API.

form_factor: "ALL_FORM_FACTORS" | "PHONE" | "DESKTOP" | "TABLET" metric: one of largest_contentful_paint | interaction_to_next_paint | cumulative_layout_shift | first_contentful_paint | experimental_time_to_first_byte Returns p75 per weekly collection period, oldest to newest. Requires CRUX_API_KEY environment variable.

Fetch a URL and validate its JSON-LD structured data schemas.

Detects all blocks, checks required fields per schema type, and suggests missing schemas based on URL patterns. Does not require authentication -- works on any public URL.

Returns detected schemas, validation results per schema, and recommendations. The valid flag and verdict check only this tool's local required-field presence rules, not full Schema.org validity or Google rich-result eligibility. Recommended properties are reported separately and do not affect validity. Verdicts: healthy (all schemas valid) | missing_schemas (none found) | invalid_schemas (found but at least one has missing required fields) | fetch_error (URL not reachable).

Generate a Schema.org JSON-LD block for one of four high-leverage types.

Adapted from scripts/schema_generate.py in claude-seo (agricidaniel, MIT). Supports: reservation, order_action, discussion, profile. No authentication required. No Google API calls made.

schema_type: one of "reservation", "order_action", "discussion", "profile". Returns the generated JSON-LD block. Verdicts: generated | error.

Capture an SEO baseline snapshot for a URL.

Fetches the page, extracts critical SEO signals (title, meta tags, canonical, headings, JSON-LD, OpenGraph), and stores them in a local SQLite database as a "known good" reference. Call drift_compare later to detect regressions.

Adapted from scripts/drift_baseline.py in claude-seo (Dan Colta methodology, MIT). No Google API calls. CWV capture requires CRUX_API_KEY (skipped otherwise).

Compare current page state to a stored baseline and report SEO drift.

Applies 17 comparison rules (8 CRITICAL, 6 WARNING, 3 INFO) and returns triggered findings with severity, old/new values, and recommended actions. Call drift_baseline first if no baseline exists for this URL.

Adapted from scripts/drift_compare.py in claude-seo (Dan Colta methodology, MIT). No Google API calls. CWV comparison requires CRUX_API_KEY (skipped otherwise).

Return recent drift comparisons for a URL.

Shows comparison timestamps, triggered finding counts by severity, and baseline IDs. Use drift_compare to run a fresh comparison.

Get Discover performance: top pages by impressions (Discover does not support query dimension).

Get Google News performance: top pages by impressions (News does not support query dimension).

Aggregate clicks and impressions broken down by search type for a site or specific URL.

Makes one GSC call per search type (web, discover, googleNews, image, video) and returns total clicks and impressions for each. If url is provided, results are scoped to that page.

Get queries where AI Overview appearance data is available.

Uses the searchAppearance dimension with dataState=all to capture AI Overview impressions. Returns an error dict when the property does not support this dimension (HTTP 400/403) instead of raising.

Compute a 0-100 health score for a single page by combining GSC, GA4, CrUX, and schema data.

Each component contributes a portion of the total score (100 pts):

• GSC (30 pts): indexing_state == "INDEXING_ALLOWED" -> 20 pts; verdict == "PASS" -> 10 pts

• GA4 (25 pts): active_users > 0 -> 15 pts; engagement_rate > 0.4 -> 10 pts

• CrUX (25 pts): LCP good -> 10 pts; INP good -> 8 pts; CLS good -> 7 pts

• Schema (20 pts): schemas found -> 10 pts; no validation errors -> 10 pts

GA4, CrUX, and Schema components are each wrapped in try/except RuntimeError so that missing credentials or insufficient data degrade the score gracefully. The final score is renormalized over available components: score = round((earned / max_available) * 100). If all components fail, returns score=0.

property_id overrides GA4_PROPERTY_ID for multi-property setups. hostname and country are forwarded to GA4 for scoped queries.

Gather SEO content intelligence for a single page: top queries, question queries, and GA4 engagement.

Step 1 — GSC: fetches search analytics with dimensions ["query", "page"], filters rows to the target page (via _normalize_url), sorts by clicks descending, and returns the top 20.

Step 2 — GA4: calls ga4_page_performance for the same page to get active_users and engagement_rate. Wrapped in try/except RuntimeError; returns None if GA4 credentials are missing or the property is not configured.

Question classification: queries whose first word (lowercased) is one of who/what/when/where/why/how.

Useful for brief-writing, content refreshes, and intent analysis.

Run a GA4 funnel report using the v1alpha RunFunnelReport API.

Each step is a dict with 'name' (display label) and 'event' (GA4 event name). Requires at least 2 steps. Returns users per step and conversion rate relative to step 1. Step 1 conversion_rate is always null. Pass property_id to override GA4_PROPERTY_ID for multi-property setups.

Analyse page content quality against Google QRG signals (E-E-A-T heuristics).

Fetches the URL, extracts visible text, then scores against thin content, filler language, information density (named entities + numbers per token), and bigram repetition. No Google API calls. No authentication required.

Filler phrase list adapted from claude-seo (agricidaniel, MIT). Verdicts: good | needs_work | thin_content | fetch_error.

Fetch a URL and validate its hreflang implementation.

Checks: missing x-default, invalid ISO 639-1 language codes, invalid ISO 3166-1 region codes, missing self-referencing tag, and mixed HTTP/HTTPS in the alternate set. Single-page audit: does not follow each alternate URL to verify bidirectional return tags.

Validation rules derived from skills/seo-hreflang/SKILL.md in claude-seo (agricidaniel, MIT). No authentication required. Verdicts: valid | issues_found | no_hreflang | fetch_error.

Audit on-page technical SEO: meta tags, canonical, robots.txt, security headers.

Fetches the URL (follow_redirects=False for SSRF safety) and /robots.txt. Checks: title and meta description length, canonical presence and consistency, meta robots directives, viewport tag, HTML lang attribute, security response headers (X-Frame-Options, X-Content-Type-Options, Referrer-Policy), redirect detection, and whether Googlebot is blocked in robots.txt.

For pages behind redirects, supply the final canonical URL directly. No Google API calls. No authentication required. Verdicts: healthy | issues_found | fetch_error.

Audit Speculation Rules, bfcache eligibility, and LCP preload signals for a URL.

Fetches the page and response headers (SSRF-safe via safe_httpx_get), then checks:

• Speculation Rules: (prefetch/prerender actions)

• Speculation-Rules HTTP response header (Chrome 122+)

• Deprecated tags (removed in Chrome 120)

• bfcache blocker: Cache-Control: no-store in response headers

Verdicts: optimised | improvements_available | not_implemented | fetch_error. No Google API calls. No authentication required. Adapted from claude-seo preload_check.py (agricidaniel, MIT).

Decompose LCP into its four subparts via the CrUX API for actionable performance diagnosis.

Returns p75 values for TTFB, resource load delay, resource load duration, and element render delay, plus the dominant phase (the subpart with the highest p75 ms). Knowing which phase dominates turns "LCP is 4.2s" into a specific fix (server, preload, image size, or render-blocking resources).

form_factor: "PHONE" (default) | "DESKTOP" | "TABLET" | "ALL_FORM_FACTORS" Requires CRUX_API_KEY environment variable. Verdicts: good | needs_improvement | poor | not_enough_data | missing_key | fetch_error. Adapted from claude-seo lcp_subparts.py (agricidaniel, MIT).

Submit URLs to IndexNow, notifying Bing, Yandex, Seznam, and Naver simultaneously.

Each URL must pass strict SSRF validation and match site's exact HTTPS origin. A 200 or 202 means only that the notification was received, never that a URL was crawled or indexed. The key is sent to IndexNow but never returned in output.

Scan URL paths for parasite SEO patterns matching Google's 2024-11-19 site-reputation policy.

Pure URL analysis, no HTTP fetches. Detects sponsored/affiliate/partner path segments, commercial product sections (/best-deals/, /top-picks/), known editorial domain patterns (Forbes Advisor /advisor/, CNN Underscored /underscored/, /select/, /commerce/), and affiliate query parameters (?ref=, ?aff=, ?partner=).

site_risk is the maximum risk level across all URLs. Verdicts: clean | at_risk | high_risk. No Google API calls. No authentication required. Adapted from claude-seo parasite_risk.py (agricidaniel, MIT).

Check robots.txt AI crawler access and llms.txt presence for a URL's origin.

Fetches {origin}/robots.txt and checks each known AI crawler agent. Also checks for {origin}/llms.txt (Model Context Protocol discoverability file). No authentication required.

Verdicts: open (all AI crawlers allowed) | partial (some blocked) | closed (all blocked or disallow all) | fetch_error.

Scan a page for deprecated Google Business Profile (GBP) features.

Checks for GBP chat widget embed scripts, dead .business.site links, and Reserve with Google (deprecated) integrations. No authentication required.

Verdicts: clean | deprecated_found | fetch_error.

Run a PageSpeed Insights audit via Google's PSI API v5.

Requires GOOGLE_API_KEY environment variable (plain API key, not service account). The PageSpeed Insights API must be enabled in the GCP project.

strategy: "mobile" (default) or "desktop". Returns Lighthouse performance score, Core Web Vitals, and top opportunities. Verdicts: good (score>=90) | needs_improvement (50-89) | poor (<50) | missing_key | fetch_error.

Audit the heading structure of a page: H1 uniqueness, hierarchy, and title overlap.

Checks that exactly one H1 exists, that heading levels do not skip (H2 straight to H4), that the is not a word-for-word copy of the H1 (a duplicate wastes a second angle on the target keyword), and that headings actually say something rather than filling a slot ("Introduction", "Conclusion").

Also reports words per H2, since a long page with no subheadings reads as a wall.

No Google API calls. No authentication required. Verdicts: healthy | issues_found | fetch_error.

Audit the internal linking of a single page, weighted by where each link sits.

Extracts every and tags it with its semantic zone (body, nav, footer, header, aside). A link in the body carries editorial weight; the same link in the footer or main nav is structural and counts for much less.

Reports internal targets that appear ONLY in demoted zones (the highest-value finding), generic anchor text, internal links marked nofollow, and self-links.

No Google API calls. No authentication required. Verdicts: healthy | issues_found | fetch_error.

Map internal link flow across a site's most-visible pages and cross it with GSC.

Takes the pages with the most impressions over days, crawls each one, and builds a directed graph of internal links tagged by the zone they sit in. Joining that graph to the Search Console numbers answers the question a link audit on a single page cannot: which pages are close to page one and receive no editorial link at all.

Outputs, in descending order of how actionable they are:

• underlinked_striking_distance: positions 11-20 with no body inbound link. Placing one internal link here is the cheapest ranking move available.

• orphan_candidates: pages with impressions and no body inbound link.

• footer_only_targets: linked from nav/footer/aside and from no page body.

• hub_pages: the pages distributing the most body links.

Coverage is bounded by max_pages (hard ceiling 100). Only crawled pages act as link sources, so "orphan" means "no link found among the pages crawled", never a site-wide certainty. pages_crawled and pages_failed are always reported.

Verdicts: healthy | issues_found | no_data.

Classify pages by measured traffic before any pruning decision is taken.

Buckets every page Search Console reports over days:

• has_traffic: at least one click. Never a candidate. Full stop.

• impressions_no_clicks: seen in results, never clicked. Review, do not delete.

• low_impressions: under 10 impressions. Weak signal, needs a human look.

• zero_impressions: no impressions at all. The only defensible candidates.

The tool deliberately returns no "delete these" list. It returns evidence, and the buckets carry the recommended action. A page absent from this report was absent from Search Console too, which is a crawling question, not a pruning one.

Pair with content_quality and internal_links_audit before acting: a page with no impressions and no internal link may be starved rather than worthless.

Return verified-state summaries for sites visible to the Bing account.

Return Bing query performance filtered to the requested rolling window.

Return Bing page performance, normalizing Bing's Query field to page.

Return Bing query performance for one requested page.

Return Bing daily clicks and impressions without inventing rank fields.

Return dated Bing crawl counts inside the requested local window.

Decode Bing crawl issue flags using the synthetic-fixture contract.

Return only Bing's observed crawl-rate value from the partial contract.

Return only fields observed from Bing URL info, without indexation claims.

Return observed URL traffic and derived CTR without rank fields.

Return Bing feeds with only the observed, non-indexation fields.

Return every Bing feed-detail row from the observed list response.

Return Bing quota integers without claiming total or remaining semantics.

Return one Bing page of backlink counts from a synthetic shape.

Return one Bing page of backlinks for the requested target URL.

Submit one same-origin URL to Bing without claiming indexation.

Preflight a Bing URL batch and refuse while quota semantics are unknown.

Submit one same-origin feed to Bing without claiming indexation.

Remove a registered same-origin feed only after explicit confirmation.

Compare Google and Bing query or page metrics without inferring causality.

Click and impression deltas are returned only when both providers expose the same exact observed window. Positions remain side by side because the two providers use different position semantics.