AuditAE SEO MCP

Create (or update) a site in the agent workspace and return its site_id, for the tools that take one (explore_llm_mentions, explore_web_mentions, mine_competitor_prompts, find_content_gap, crawl_site, detect_tech_stack, get_backlink_summary, submit_urls, schedule_recheck). Creates the workspace on first use and returns its API key. Billing: bundled — free. Example: { domain: "linear.app", brand: "Linear", competitor_domains: ["asana.com"] }

Remove a recheck created by schedule_recheck before it fires. A pending recheck hasn't been charged anything, so there is nothing to refund. One that has already fired can't be cancelled — its checks bill as they run — and returns error already_ran with its audit_id. Billing: free. Returns { recheck_id, cancelled: true } or { error: not_found | already_ran | not_pending, status, detail }. Example: { recheck_id: "…" }

Score a site 0–100 on agent readiness: whether an AI assistant acting for a buyer can reach it, read what it sells and at what price, and find its machine interfaces. Billing: free. Fetches ~10–14 URLs on the target site; takes 5–15 s. Cached 10 min per URL; 30 uncached checks per hour per host. Checks: agent fetchers (ChatGPT-User, Claude-User, Perplexity-User) allowed in robots.txt; no CDN/WAF bot wall when fetched as ChatGPT-User; Product / SoftwareApplication / Service JSON-LD with an Offer price; prices in the pricing page's server-rendered HTML; an MCP server card at /.well-known; robots.txt Content-Signal; UCP/ACP checkout endpoints (stores only); A2A agent card. Different from run_technical_audit (whether answer-engine crawlers may crawl the site, /llms.txt served). Run this for agentic commerce, 'can ChatGPT buy from us', or MCP / agent discoverability. Stores: the site counts as a store when the homepage has Product JSON-LD, storefront markup (add-to-cart, Shopify / WooCommerce cart code) or a /cart link; store_reason says which. A store's Product markup is graded on a product page found through homepage links or the sitemap (or the product URL you pass as `domain`). When none is found, offer_schema is "na" instead of failing on the homepage. schema_urls_checked lists every URL whose JSON-LD was read. Inputs: domain — hostname or URL, e.g. "example.com" (a product page URL is also graded for Product markup). Output: { domain, score, grade, earned, possible, store, store_reason, product_url, pricing_url, schema_urls_checked, checks: [{ key, label, status: pass|partial|fail|na, earned, possible, why, detail, fix: { summary, code? } | null }], suggested_next, next_step, blocked?, not_checked? }. Failing checks carry a paste-ready fix. If bot protection refuses us (401/403/429/503): blocked: { http_status, as_agent_http_status, summary } plus not_checked. Relay blocked.summary as written; it doesn't show whether search crawlers get in, so don't call the site invisible to AI search from it.

Read a site's robots.txt and report, for each AI crawler and assistant (GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot, Claude-User, PerplexityBot, Perplexity-User, Google-Extended, Applebot-Extended and more), whether it may crawl the site, with the deciding rule. Also requests the homepage as a few AI bots to spot firewall/CDN blocks robots.txt doesn't show, and returns paste-ready robots.txt fixes. Billing: free. Inputs: domain — hostname or URL. Returns { domain, robots_txt, summary: { blocked, limited, training_blocked, unclear, likely_blocked_by_firewall, robots_unknown }, bots: [{ bot, owner, purpose, verdict, note? }], firewall_probe, llms_txt_blocked_for, fixes: [{ title, robots_txt, bots }], cached_at, since_last_check?: { previous_check_at, changed, changes: [{ item, before, now }] }, suggested_next: { tool, args, price_cents, price_label, why }, next_step }. suggested_next is the one priced step after it (relay once; run only if the user agrees). The firewall probe uses the bots' user-agents, not their IP addresses: a block there is a strong hint, not proof (caveat says so).

Ask one prompt of AI answer engines and report, per engine, whether the brand's URL was cited, whether and where the brand was named, which competitors were named, the cited sources and the sentiment. The run is saved as an audit. Billing: 5–12¢ per engine check plus the fix-it playbook — Perplexity 5¢, ChatGPT 7¢, Google AI Overviews 9¢, Gemini 12¢ (33¢ per prompt on the four default engines), Google AI Mode 10¢ when requested. Only answered checks bill; a repeat within an hour is served from cache at full price. After the checks AuditAE writes a fix-it playbook for each answered check that didn't cite the brand, billed on LLM usage (about 12¢ each), plus about 45¢ for the audit rollup — one prompt on the four default engines is about 126¢ if no engine cites the brand. charged_cents in the response is what the run billed. When to call: the user asks whether an engine cites or names the brand for a question, or wants a prompt re-checked after a fix. To read an existing audit, use get_audit. Inputs: brand — as written in prose (e.g. "Linear"). domain — the brand's primary domain (e.g. "linear.app"); matched against sources, not fetched. prompt — the question to ask (e.g. "best pm tool for startups"). engines — optional subset of [chatgpt, perplexity, gemini, ai-overviews, ai-mode]; default the first four. Returns { audit_id, report_url, results: [{engine, prompt, status, brand_mentioned, brand_url_cited, position, competitors, sources, sentiment, was_cache_hit, error_message, answer_excerpt}], citation_rate, completed, total, partial, out_of_credits, charged_cents, charged_breakdown_cents: {checks, playbook} }. report_url is a shareable public report — give it to the user. A playbook that doesn't finish in the call finishes in the background. Past ~45 s it returns { audit_id, status: "running", next_step } and finishes in the background; read it with get_audit (free). Example: { brand: "Linear", domain: "linear.app", prompt: "best project management tool for startups", engines: ["perplexity"] }

Ask one buyer question of ChatGPT, Perplexity, Gemini and Google AI Overviews and report, per engine, whether the brand's site is cited as a source, whether the brand is named, and who is named instead. Returns a shareable report link. Billing: free — one fresh check per connection per day (repeats of the same check within 24h are free too); no account needed. Inputs: brand — as written in prose. domain — the brand's site. question — optional buyer question; omitted, the question last checked for this site is asked again (so the result shows what changed), or one is written for the brand. Returns { brand, domain, question, cached, citation_rate, cited_on, engines: [{ engine, answered, site_cited, brand_named, position, named_instead, sources }], report_url, since_last_check?, suggested_next?, next_step }. position is the brand offset, not a rank: characters into the answer where the brand is first named (lower = named earlier; null if not named). sources are the cited URLs, utm_* tags removed. since_last_check compares with the last time this question was checked for the site (gained, lost). For more questions, the other engines' detail and fixes, a free AuditAE account runs check_brand_citation (paid from its $5 starting credit).

Fetch a site's /llms.txt and validate it against the llms.txt format: served as plain text, an H1 title, summary, sections of links with descriptions, links that resolve. Reports each finding by line with its severity. Billing: free. Inputs: domain — hostname or URL. Returns { url, status, missing, verdict: pass|warn|fail, counts, findings: [{ line, severity, code, message }], links_checked, links_not_checked, cached_at, since_last_check?, suggested_next, next_step }. suggested_next is the one priced step after it (on a paired WordPress site with no usable file, the plugin's llms.txt reset). missing: true means no usable file (an error status or a fetch error). On a WordPress site the free AuditAE plugin serves and maintains llms.txt automatically.

Compare two crawl_site runs of a site: the Site Health and theme score changes, and per check how many issues are new and how many were fixed, plus pages added, removed or changed status, and robots.txt rule changes. Billing: free — compares stored crawls; nothing is fetched. Defaults to the site's latest scored crawl against the one before it (the previous scored crawl graded with the same check version, preferring one crawled with the same settings scope; a different scope gives scope_changed: true and no pages added/removed). Pass run_id and base_run_id (from history[].run_id) for any two. Crawls graded with different check versions compare totals only (mode "summary": new/fixed and the health delta are null). Crawls made before Site Audit checks can't be compared. Inputs: site_id — the AuditAE site id (from list_sites). run_id — optional run to read; default the latest scored crawl. base_run_id — optional earlier run to compare it with; default the crawl before it. Returns: { site_id, run: { run_id, started_at, site_health }, base: { run_id, started_at, site_health } | null, comparison: { mode, health: { from, to, delta }, counts, themes: { <id>: { from, to, delta } }, totals: { new_errors, fixed_errors, new_items, fixed_items }, checks: [{ id, severity, from, to, new, fixed, removed, new_s, fixed_s }] (changed only, biggest change first), pages: { added, removed, status_changed, became_broken, became_noindex, became_indexable, title_changed, samples } | null, robots: { changed, added_rules, removed_rules }, sitemap } | null, history: [{ run_id, started_at, site_health, health_delta, errors, warnings }] (≤12), note?, suggested_next?, next_step }. new/fixed count pages for page checks. For the URLs behind a check's change, get_crawl_issue with compare "new" or "fixed". base null: the first scored crawl.

Crawl a whole site and audit it: the homepage, the sitemap and every internal link (robots.txt respected), up to max_pages, then 170+ Semrush-style checks graded error / warning / notice, a Site Health score (0–100) and 9 theme scores (crawlability, HTTPS, international SEO, Core Web Vitals, performance, internal linking, markup, AI search, on-page). Billing: 1¢ per 10 pages fetched (1,000 pages = $1.00, 10,000 = $10.00), billed as it crawls; the link, image and script checks (up to 5,000 per crawl), the site checks (HTTPS, www, TLS, soft 404, llms.txt, AI fetchers) and Core Web Vitals on up to 10 pages are included at no extra charge. It stops as "partial" if the balance runs out. Confirm max_pages and the most it can cost with the user first. Timing: about 3–6 pages a second, then a short link-check and scoring stage; Core Web Vitals follow a few minutes after completion (cwv_state "pending" until then; their theme only, never Site Health). It runs ~40 s in this call: a small site comes back complete, a bigger one returns status "running" and keeps crawling in the background — read it later with get_latest_crawl (free). One page instead: run_technical_audit. Inputs: site_id (list_sites), max_pages (1–10000, default the whole site), seed_url (optional, on the site). Optional settings (source, include/exclude, ignore_params, subdomains, robots_agent, device, speed, cwv_urls): see each input; leave them out to crawl the whole site. Returns: { run_id, site_id, status: running|complete|partial|failed, stage, coverage, pages_crawled, pages_found, pages_failed, skipped_by_rules, charged_cents, billed_cents (same), max_cost_cents, settings?, rejected?, site_health, counts: { errors, warnings, notices }, themes, cwv_state, checks: [{ id, severity, title, n, of }] (failing, worst first, ≤30), issues_summary (counts), top_problem_pages (≤5: { url, http_status, checks }), note, next_step }. While running, checks are provisional page counts so far. For one check's URLs, evidence and fix call get_crawl_issue (free).

Create a one-time Stripe Checkout link that adds prepaid credit to this AuditAE workspace. Nothing is charged by this call: give the returned url to the user, who opens it and pays by card. Credit lands within seconds of payment; call get_balance to confirm. Billing: free — the user pays only if they complete the checkout. The link expires after 24 hours. When to call: a paid tool returned out_of_credits, or get_balance shows too little for the run the user asked for. Suggest an amount that covers the planned work (prices are in each tool's description) and tell the user what it's for. For an agent workspace (no account behind it) the result also has claim_url: a link the user opens to sign up and take over the workspace. Inputs: amount_cents — whole cents, 500–100000 ($5–$1000). Example: { amount_cents: 2500 }

Detect the technology a site runs on (CMS, ecommerce platform, analytics, JavaScript frameworks, CDN, servers, and hosting such as Vercel, Netlify or Heroku) via DataForSEO Domain Analytics, and cache it on the site. Use it to tailor fix instructions to the platform (WordPress vs Shopify vs Webflow vs a custom Next.js app) before recommending changes. Billing: free. A stack detected in the last 7 days is returned from the site's stored profile (detected_at says when); older ones are re-detected. Inputs: site_id — the AuditAE site id (from list_sites). Output: { site_id, domain, detected_at, detected_cms, is_wordpress, technologies: { cms, ecommerce, analytics, javascript, cdn, servers, hosting }, all: [every technology name detected] }, or { detected: false } when DataForSEO has no data for the domain; error provider_unavailable when the lookup failed (retry). Detection is DataForSEO's index, which can lag a recent platform change.

Find a brand's Wikidata entity and return the URLs to use in Organization.sameAs: the Wikidata page, English Wikipedia, X/Twitter, LinkedIn company, Crunchbase, GitHub, YouTube, Facebook, Instagram, plus its official site and Google Knowledge Graph entity. Billing: free — Wikidata's public API, no LLM tokens. Matching is strict: found:true only when a candidate's Wikidata official website (P856) matches `domain` (matched_by:"domain") or you pin an entity with `qid` (matched_by:"qid"). Otherwise found:false with same_as:[] and `candidates` (qid, label, description, official_site, domain_matched) plus a `next_step`: ask the user to supply their brand's profile URLs themselves (Wikidata, Crunchbase, LinkedIn, X, YouTube — 5-10 authoritative ones). Never put a candidate's URLs in sameAs unless the user confirms it is their brand; then call again with its qid. google_kg is the brand's Google Knowledge Graph entity, same rule: matched by `domain` (its website) or the Wikidata item's KG id, never by name. google_kg_status "not_confirmed" means no KG result could be tied to the brand, not that Google has no entity; Organization schema whose sameAs lists the Wikidata item, and a Wikidata item with the official website and Google KG ID, make it provable. "unavailable": the lookup couldn't run; conclude nothing. When to call: before writing Organization schema (wp_set_organization_schema), Article.publisher or Product.brand. Always pass domain. Returns: { found, domain_matched (null without a domain), matched_by, wikidata_qid, label, description, official_site, same_as, detail: { wikipedia_url, twitter, linkedin, crunchbase, github, youtube, facebook, instagram, google_kg }, candidates, google_kg: { kg_id, name, types, description, detailed_description_url, url, result_score, domain_matched, wikidata_id_matched } | null, google_kg_status: matched|not_confirmed|unavailable, next_step? }. A pinned qid whose site doesn't match domain comes back with domain_matched:false and a next_step to confirm with the user.

Hits DataForSEO's LLM Mentions corpus to return the observed AI prompts where a target shows up: the LLM answer, its cited sources (with position + publication date), and a 12-month volume trend. Covers Google AI Overviews (worldwide) + ChatGPT (US/EN). Different from live engine audits — this is a corpus DataForSEO has already crawled, so you get historical depth + competitor coverage without re-querying. Billing: 75¢ per call — one flat fee whatever the limit. Not billed when nothing is found or the lookup fails. Inputs: site_id — the site to attach the saved report to (required — MCP doesn't auto-pin a site). target_type — "domain" (returns every prompt citing this domain) or "keyword" (returns the AI answer + every cited domain for this prompt/topic). target — the domain (e.g. "linear.app") or keyword (e.g. "best pm tool for startups"). platform — "google" (default, AI Overviews worldwide) or "chat_gpt" (US/EN only). limit — prompts to pull from the corpus (default 50, max 100); all of them count toward prompt_count and unique_domains_cited. Output: { report_id, url, title, target, platform, prompt_count, unique_domains_cited, prompts_returned, charged_cents, prompts: [{question, answer_preview, sources: [{domain, url, position, publication_date}], ai_search_volume, monthly_trend}] } — prompts holds the 25 with the most AI search volume, each with up to 10 cited sources; url opens the saved kind="llm_mentions" site_report (top 20 by volume) in the dashboard. Example: { site_id: "…", target_type: "domain", target: "asana.com" }

Hits DataForSEO's Content Analysis index to return open-web content (news, blogs, forums, ecommerce, organizations) that mentions a brand/keyword, each tagged positive / negative / neutral. The web-side companion to explore_llm_mentions (AI answers) — together they give full share-of-voice across AI and the open web. Billing: 25¢ per call — one flat fee whatever the limit. Not billed when nothing is found or the lookup fails. Inputs: site_id — the site to attach the saved report to (required). keyword — the brand or keyword to monitor (e.g. "Linear" or "linear.app"). page_type — optional content vertical: "news", "blogs", "message-boards", "ecommerce", or "organization". Omit to search everything. limit — max mentions to sample (default 50, max 1000). Output: { report_id, url, title, keyword, page_type, total_count, sample_count, sentiment: {positive, negative, neutral}, charged_cents, mentions: [{sentiment, domain, url, title, date_published}] } — mentions lists up to 50 of the sampled pages, negative first; url opens the saved kind="web_mentions" site_report in the dashboard. Example: { site_id: "…", keyword: "Linear", page_type: "news" }

Given an arbitrary block of text and a brand of interest, return the list of competitor brand names mentioned (excluding the brand itself, and the AI assistants and search engines the text cites as sources, such as ChatGPT or Perplexity) and the sentiment toward the brand (positive | neutral | negative). Audits use the same extractor for their competitor lists. Billing: free — uses no AuditAE credit and works at a zero balance. Inputs: brand up to 200 characters; text up to 20,000 characters (send the relevant part of a longer answer). Returns { competitors, sentiment, charged_cents: 0 }, plus error when the extraction couldn't run (competitors is then empty because nothing was read). Example: { brand: "Linear", text: "Linear is a great choice, though many teams pick Asana or Jira for their wider integrations." }

Pull DataForSEO Labs domain_intersection for (site_domain, competitor_domain) and return the keywords the competitor ranks for in Google search that the user's site doesn't — plus keywords where the competitor outranks the user. Sibling SKU to mine_competitor_prompts: that one is AI-engine citation gap, this one is classic SEO ranking gap. Billing: 25¢ per run. The same site, competitor, location, language and limit within 24h is served from cache free (charged_cents=0). Not billed when the site_id or competitor_domain is rejected, or when no keywords come back (charged_cents=0). When to call: the user asks 'what does <competitor> rank for that we don't', 'show me Google content gap vs <competitor>', 'keywords <competitor> ranks for'. Returns: { rows: [{keyword, search_volume, cpc_cents, kd, intent, competitor_position, user_position, competitor_url, user_url, gap_kind: 'they_rank_we_dont'|'they_outrank_us'|'co_ranked'}], user_domain, competitor_domain, location_code, language_code, generated_at, cache_hit, charged_cents }. The site_id must belong to this workspace and the competitor_domain must be on the site's competitor list (list_sites shows site_ids and each site's competitor_domains; a rejected domain returns error competitor_not_on_site with valid_competitor_domains). Example: { site_id: "...", competitor_domain: "asana.com", location_code: 2840, language_code: "en" }

Build a complete schema.org JSON-LD object for Article, BlogPosting, HowTo, FAQPage, Product, Organization, BreadcrumbList, WebSite, SoftwareApplication, Service or LocalBusiness from a few fields, then validate it. Billing: free — deterministic, no network, no LLM tokens. Returns: { schema, validation, ignored_fields, notes, suggested_next?, next_step? } (suggested_next as validate_schema's). validation is validate_schema's result on the schema. ignored_fields lists input keys that are neither a generator field nor a schema.org property of the type (usually typos, with a 'did you mean'); fix and re-run rather than shipping without them. notes lists values that were rewritten (a relative path resolved against siteUrl, '15 minutes' → PT15M, '$49' → 49). URLs: relative paths (/pricing, /wp-content/…) are resolved against data.siteUrl, else the entity's own url (for BreadcrumbList, the first absolute item url); with no base they're rejected, as are @handles in sameAs — pass full profile URLs. Bare domains (example.com) get https://. Errors: bad or missing input returns isError with every problem listed at once (e.g. 'data.faqs is required…', 'data.items[1].url '/pricing' is a relative path…'). When to call: any time you'd otherwise hand-write JSON-LD. Pipe `schema` into wp_set_*_schema once validation.valid is true. For sameAs, call discover_brand_entities first. Link WebSite/Article publisher to your Organization by passing publisherId (its @id). Inputs: type, and data (per-type fields are listed on the data input).

Read the stored results of an AuditAE audit — per prompt and per engine: whether the brand's URL was cited, whether the brand was named, which tracked competitor domains were cited and which competitor names were mentioned, and the cited source URLs — plus summary rates and a shareable report_url. Asks no engine. Billing: free — reads stored results only; works at a zero balance. When to call: to see where competitors get cited instead of the brand before paying for new checks — with list_sites' latest_audit.audit_id, or the audit_id that check_brand_citation, get_share_of_voice, get_fix_plan or get_recheck returned. Then call get_fix_plan with that audit_id. Inputs: audit_id — required. only_lost — true for only the answered cells where the brand's URL was not cited. prompt — only prompts containing this text (case-insensitive). max_urls — cited URLs per cell, default 5 (0–50); the brand's and tracked competitors' URLs are always listed. include_answers — true to add answer_excerpt: about 320 chars of each answer, around the brand mention when there is one. Returns { audit_id, brand, domain, status, created_at, engines, prompt_count, competitor_domains, visibility_score, failure_reason, report_url, charged_cents, charged_breakdown_cents: {checks, playbook}, summary: {answered, total, cited, mentioned, citation_rate, mention_rate, prompts_lost, by_engine: [{engine, answered, cited, mentioned}], competitors: [{domain, cited_cells, cited_where_brand_not}], top_cited_domains: [{domain, cells}], top_competitors_mentioned: [{name, cells}]}, results: [{prompt, engines: [{engine, status, cited, mentioned, competitors_cited, competitors_mentioned, urls, more_urls?, answer_excerpt?}]}], suggested_next?, next_step? }. A cell the engine didn't answer is {engine, status, error}. summary covers every cell; the filters only narrow results. While status is "running", results and charged_cents cover the cells answered so far; report_url is null until it's complete. Example: { audit_id: "…", only_lost: true }

Return a domain's off-page authority from DataForSEO's backlink index: domain rank, total backlinks, referring domains, dofollow referring domains, spam score and broken backlinks. A major driver of why competitors out-rank and out-cite a site. Without `domain` it checks the site (cached on it for 24 h); pass `domain` to check a competitor instead. Billing: free. Up to 50 new `domain` lookups a day per workspace (repeats within 24 h don't count). Inputs: site_id — the AuditAE site id (from list_sites). domain — optional other domain to check (cached 24 h). Output: { site_id, target, rank (0–1000, DataForSEO domain rank; higher = stronger), backlinks, referring_domains, dofollow_referring_domains, spam_score (0–100, DataForSEO's backlink spam score; higher = more links from spammy sites), broken_backlinks }, or { found: false } when the index has no data for the domain. Errors: provider_unavailable (the lookup failed; retry), rate_limited.

Return the current prepaid credit balance for this AuditAE workspace, the price of one check on each engine, roughly how many checks the balance covers per engine, and the auto-refill setup. Billing: free — works at a zero balance. When to call: before a large paid run (get_share_of_voice across many prompts, crawl_site on 100 pages) to check it will fit, or after a tool returned out_of_credits. Returns { balance_cents, balance_usd, available_cents, prices_cents_per_check, estimated_checks_left, auto_refill: { enabled, has_card, amount_cents, threshold_cents, monthly_cap_cents, cap_reached_this_month } | null, billing_url }. available_cents is what a new paid run can use now (the balance less credit held by runs in flight); estimated_checks_left is based on it. billing_url is null for an agent workspace (use create_top_up_link).

What moved for a site: first its weekly briefing, if any (this week's moves and up to 5 priced fixes); then, since the previous check, per buyer question and engine, where the brand gained or lost a citation (its URL among the answer's sources), and for a lost one the domains cited instead and competitors named; plus tracked keywords that moved in Google. Compares the newest completed citation audit with the newest earlier one on the same questions. Billing: free — reads stored results only; asks no engine and works at a zero balance. When to call: at the start of a session about a site, when the user asks how they're doing or what changed, or after a monitor_citations run. Inputs: site_id — from list_sites; or domain instead. audit_id (optional) — compare this audit (from list_sites or get_audit) with the one before it, instead of the newest; use it when the newest is a one-question spot check. Returns { briefing: {briefing_id, week_of, headline, stats: [{label, value, delta_label, period}], summary, findings, offers: [suggested_next shape + offer_id], dashboard_url} | null, site_id, domain, headline, citations: { current: {audit_id, ran_at, cited, mentioned, answered, url}, previous | null, compared_cells, cited_before, cited_after, gained: [{prompt, engine, brand_url}], lost: [{prompt, engine, cited_instead, competitors_named}], mention_gained, mention_lost, new_cells } | null, keywords: { tracked, up, down, unchanged, moved: [{keyword, position, previous_position, change, url, checked_at}] } | null, monitor: {monitor_id, status, cadence, next_run_at} | null, crawl: {run_id, completed_at, site_health, health_delta, new_errors, fixed_errors, top_new_errors: [{id, title, new}]} | null, next_step }. crawl is the latest scored Site Audit crawl and what changed since the one before. headline is a one-line summary to relay; briefing.stats are the week's figures. Lists are capped at 25. Relay the briefing's fixes with prices; run one only if the user agrees. Example: { domain: "acme.com" }

The domains competing with any domain in Google: who ranks for the most of the same keywords, how many they share, their average position on those, and each competitor's own organic keyword count and estimated traffic. Big generic sites (Google, YouTube, Wikipedia…) are left out. DataForSEO's Google index; estimates. Billing: 10¢ per call. Not billed when nothing comes back or the call fails; the same call again within 24h is free. On the no-account server, a caller without credit gets one data call a day free. Inputs: domain — e.g. "linear.app". country — ISO code (US, CA, GB, AU, NZ, IE, IN, SG, ZA, DE, FR, ES, IT, NL, SE, MX, BR); default from the domain's TLD, else US. limit — 5–50 competitors, default 20. Returns { domain, country, competitors: [{domain, shared_keywords, avg_position, shared_keywords_traffic, organic_keywords, estimated_monthly_traffic}], cached, charged_cents }. Feed a competitor to get_domain_keywords to see what it ranks for. Example: { domain: "linear.app", limit: 10 }

Read one check from a site's latest crawl_site run (or run_id): what it means, why it matters, how to fix it, which MCP tools fix it, and the affected URLs with evidence, paginated. check_id comes from crawl_site / get_latest_crawl checks[].id. Billing: free — reads the stored crawl; nothing is fetched. Inputs: site_id — the AuditAE site id (from list_sites). check_id — a check id, e.g. "title_missing" or "broken_internal_link". run_id — optional earlier run (get_latest_crawl history[].run_id); default the latest. limit — items per call, default 25, max 100; offset — pass next_offset. compare — optional 'new' or 'fixed': only the pages that started failing since the previous crawl ('new'), or that failed then and don't now ('fixed': fixed, or the page now errors or redirects; evidence from that crawl), plus vs_previous { from, to, new, fixed }. Link, image and script checks list new items only. base_run_id — with compare: the earlier run (history[].run_id); default the crawl this one was compared with. Returns: { site_id, run_id, check: { id, title, severity, themes, scope, rule, why, fix, fix_tools, semrush_ids }, status: fail|pass|not_run|pending, n, of, items: [{ url, evidence }], total, next_offset, groups?, compare?, vs_previous?, note? }. Page checks list every failing page; site-wide checks one item; duplicate and broken-link checks add their groups on the first call. After fixing, submit_urls with the changed URLs, then crawl_site again to confirm. { error: "run_predates_checks" }: crawled before Site Audit checks; crawl again.

The Google keywords any domain ranks for (its own site or a competitor's), ordered by the traffic each sends: position, ranking URL, monthly search volume, CPC, keyword difficulty and search intent, plus the domain's totals — organic keyword count, estimated monthly organic traffic and its ad value, and how many keywords are new, up, down or lost. DataForSEO's Google index, refreshed monthly; estimates, not the site's own Search Console numbers (query_search_console has those for a connected site). Billing: 10¢ per call. Not billed when nothing comes back or the call fails; the same call again within 24h is free. On the no-account server, a caller without credit gets one data call a day free. Inputs: domain — e.g. "linear.app". country — ISO code (US, CA, GB, AU, NZ, IE, IN, SG, ZA, DE, FR, ES, IT, NL, SE, MX, BR); default from the domain's TLD, else US. limit — 10–60 keywords, default 50. Returns { domain, country, totals: {organic_keywords, estimated_monthly_traffic, traffic_value_usd, top_3, positions_4_10, positions_11_20, new, up, down, lost}, keywords: [{keyword, position, previous_position, url, search_volume, cpc_usd, keyword_difficulty, intent, estimated_traffic}], cached, charged_cents }. Example: { domain: "linear.app", limit: 25 }

Turn the site's AuditAE audits into a ranked list of exact changes that get the brand cited by AI engines (ChatGPT, Perplexity, Gemini, Google AI Overviews) instead of competitors — sentences to rewrite, FAQs, title and meta, JSON-LD, missing pages — for any website. Billing: 50¢ per plan. Free (charged_cents=0): the same request again within 24h, every error, and plans with nothing left to fix. When to call: before editing a site for AI-search visibility, or when the user asks what to fix or why competitors get cited. Pass page_url for exact find/replace edits on that page (recommended); omit it for a site-wide plan. Site-wide, it uses the most comprehensive recent audit (pass audit_id to choose one); with page_url, the recent audit whose prompts are about that page. It checks the live site first (sitemap, llms.txt, robots.txt, homepage links, JSON-LD). Fixes already live are kept with already_done: true and `evidence` — skip them. Drafts: a fix with draft: true states facts the site doesn't show, listed in needs_input. Ask the user to confirm or supply each one, work in only what they confirm, and never publish a draft as-is. Copy without draft is grounded in the site's own content. Applying: follow how_to_apply and each fix's `apply` steps and paste-ready `code` for the detected `platform` (paired WordPress: the wp_* tools in `tools`). Once live: submit_urls with the changed URLs, inspect_url to confirm Google indexed them, then schedule_recheck with verify_prompts and audit_id. Errors (unbilled; see `message`): no_audit, nothing_to_fix, no_relevant_audit, nothing_left_to_fix (lists already_done), truncated, empty_plan, fetch_failed (retry once), not_configured, page_fetch_failed, page_not_on_domain, out_of_credits. Returns { summary, platform, how_to_apply, fixes: [{priority, kind, page, title, why, already_done, evidence, draft?, needs_input?, find?, replace?, content?, faq?, meta?, code?, apply, tools, closes_prompts}], verify_prompts, site_check, audit_id, report_url, charged_cents, cache_hit }.

Metrics for up to 60 keywords in one call: monthly Google search volume, the last 12 months, the trend (month, quarter, year), CPC, ad competition, keyword difficulty (0–100) and search intent. For new keyword ideas around a topic use keyword_research instead. Billing: 10¢ per call (1–60 keywords). Not billed when nothing comes back or the call fails; the same call again within 24h is free. On the no-account server, a caller without credit gets one data call a day free. Inputs: keywords — 1–60 keywords. country — ISO code (US, CA, GB, AU, NZ, IE, IN, SG, ZA, DE, FR, ES, IT, NL, SE, MX, BR); default US. Returns { country, keywords: [{keyword, search_volume, monthly_searches: [{month, volume}], trend_pct: {monthly, quarterly, yearly}, cpc_usd, competition, keyword_difficulty, intent}], not_found, cached, charged_cents }. not_found lists keywords with no data (too rare or new). Example: { keywords: ["crm software", "best crm for startups"], country: "US" }

Read a site's latest crawl_site run (or run_id): Site Health 0–100, theme scores, every failing check, what wasn't checked and problem pages. Billing: free — reads the stored run; nothing is fetched. Staleness: a run older than 30 days, or made before the crawler fixes of 2026-09-24, has stale: true — don't verify fixes against it; crawl again. Every page failed: status "failed". A run crawled before Site Audit checks has coverage: "legacy" (issue rollup only). cwv_state "pending": Core Web Vitals still measuring; read again in minutes. Never report not_run checks as passed. Inputs: site_id — the AuditAE site id (from list_sites). run_id — optional earlier run (history[].run_id). theme — adds that theme's report: score, its checks with why and fix, and details (status, depth and load-time buckets, robots, sitemaps, TLS, hreflang, per-page Core Web Vitals, AI bot access). severity — error, warning or notice: filters checks. checks — with theme: 'failing' (default) or 'all' (adds passed). check — a check id: pages are those failing it, plus its rule, why and fix. pages — 'issues' (default; 'none' with theme: pages failing an error or warning check, worst first, as { url, http_status, depth, checks, inlinks, ilr }), 'all' or 'none'. limit — pages per call, default 10 (legacy runs 25), max 100; offset — pass next_offset. Returns: { site_id, run: { run_id, status, completed_at, pages_crawled, billed_cents, settings, … }, stale, coverage, stage, site_health, counts (by severity), themes: { <id>: { score, failing, ran } }, cwv_state, checks: [{ id, severity, title, n, of }] (≤40, worst first), not_run: [{ id, reason }], vs_previous? (change since the crawl before; incomplete_baseline?/note?: a capped crawl inflates new; diff: compare_crawls), history (last 5 runs), schedule, theme?, check?, issues_summary (counts), pages_view, pages_total, next_offset, pages, suggested_next?, next_step, note? }. While crawling: provisional: true counts. { run: null }: never crawled.

Read a recheck created by schedule_recheck. Before it runs: its status and run_at. Once it has run: per prompt and per engine, before (the baseline audit) vs after (the recheck) — which prompts the brand gained or lost a citation on (its URL among the answer's sources) and gained or lost a mention on (named in the answer). Billing: free — reads stored results only; asks no engine and works at a zero balance. When to call: when the user asks whether their fixes worked, or once a recheck's run_at has passed. Pass recheck_id for one recheck; without it, pass site_id or domain to list that site's rechecks, or nothing to list the workspace's. Status: scheduled (waiting for run_at) | queued | running | complete | failed | paused (its site was archived before it ran — it won't run; schedule a new one). Returns for one recheck: { recheck_id, status, headline, site_id, domain, brand, label, scheduled_at, run_at, ran_at, prompts, engines, baseline: {audit_id, completed_at} | null, audit_id, report_url, audit_url, failure_reason, out_of_credits, answered, attempted, total, charged_cents, charged_breakdown_cents: {checks, playbook}, summary: {compared_cells, cited_before, cited_after, mentioned_before, mentioned_after, citation_gained: [{prompt, engine}], citation_lost, mention_gained, mention_lost, no_baseline}, results: [{prompt, engines: [{engine, before: {cited, mentioned} | null, after, after_error, citation, mention}]}] }. citation and mention are gained | lost | kept | still_missing, or null when either side has no answer. summary counts cover cells answered in both runs. headline is a one-line verdict to relay to the user. Returns for a list: { rechecks: [{recheck_id, status, site_id, domain, label, scheduled_at, run_at, ran_at, prompt_count, engines, audit_id}] }. Example: { recheck_id: "…" }

Live Google results for any keyword in a country: the organic top 10–30 (position, domain, URL, title, snippet), whether an AI Overview shows and which domains it cites, the featured snippet owner, People Also Ask questions and the SERP features present. Billing: 5¢ per call. Not billed when nothing comes back or the call fails; the same call again within 24h is free. On the no-account server, a caller without credit gets one data call a day free. Inputs: keyword — the search query. country — ISO code (US, CA, GB, AU, NZ, IE, IN, SG, ZA, DE, FR, ES, IT, NL, SE, MX, BR); default US. results — 10–30, default 10. device — desktop (default) | mobile. Returns { keyword, country, device, checked_at, ai_overview: {present, cited_domains}, featured_snippet_owner, people_also_ask, serp_features, results: [{position, domain, url, title, description}], google_url, cached, charged_cents }. Example: { keyword: "best crm for small business", country: "US" }

Ask up to 25 prompts of AI answer engines and count how often each tracked domain — the brand's plus its competitors' — is cited as a source. Returns per-domain cite counts and share-of-voice percentages; the run is saved as an audit (read it per prompt with get_audit, free). Billing: 5–12¢ per engine check plus the fix-it playbook — each answered prompt × engine is one check: Perplexity 5¢, ChatGPT 7¢, Google AI Overviews 9¢, Gemini 12¢ (33¢ per prompt on the four default engines), Google AI Mode 10¢ when requested. After the checks AuditAE writes a fix-it playbook for each answered check that didn't cite the brand, billed on LLM usage (about 12¢ each), plus about 45¢ for the audit rollup. E.g. 10 prompts on the default engines: 330¢ of checks, plus about 525¢ of playbook if no answer cites the brand. charged_cents in the response is what the run billed. Limits: the engines get about 4 minutes; checks that don't finish are skipped, unbilled (partial, timed_out) — split runs past ~15 prompts. A balance that runs out mid-run sets partial and out_of_credits. Inputs: brand, domain — as in check_brand_citation. competitor_domains — up to 20 domains to count, e.g. the site's competitor_domains from list_sites. prompts — 1–25 buyer questions. engines — optional subset of [chatgpt, perplexity, gemini, ai-overviews, ai-mode]. Defaults to the first four; ai-mode is opt-in. Returns { audit_id, report_url, tracked: [{domain, is_brand, cite_count, share_pct}], total_cites, completed, total, partial, timed_out, out_of_credits, charged_cents, charged_breakdown_cents: {checks, playbook} }. cite_count counts answered checks citing the domain. report_url is a shareable public report — give it to the user. Past ~45 s (most runs over 3 prompts) it returns { audit_id, status: "running", next_step } and finishes in the background; read it with get_audit (free). Example: { brand: "Linear", domain: "linear.app", competitor_domains: ["asana.com", "notion.so"], prompts: ["best pm tool for startups", "linear vs asana"] }

Return every active (non-archived) site in this AuditAE workspace: its site_id, domain, brand, name, the competitor domains tracked for it, when it was added, its latest completed citation audit (with a shareable report_url), and its paired WordPress connection. Billing: free — read-only lookup against AuditAE's database; works at a zero balance. When to call: first, before any tool that takes a site_id (e.g. mine_competitor_prompts, find_content_gap, schedule_recheck, explore_llm_mentions, explore_web_mentions, crawl_site, get_latest_crawl, detect_tech_stack, get_backlink_summary, submit_urls) — use the site_id values it returns, and pass only domains from that site's competitor_domains as competitor_domain. check_brand_citation and get_share_of_voice take no site_id: pass a site's domain and brand (and, for get_share_of_voice, its competitor_domains). Pass latest_audit.audit_id to get_audit (free) to see, per prompt and engine, where competitors are cited instead of the brand. Also when the user asks which sites or competitors are tracked, or whether a site has been audited. Returns { sites: [{ site_id, domain, brand, name, competitor_domains, created_at, latest_audit: { audit_id, completed_at, prompt_count, engines, citation_rate (0–1), report_url } | null, wordpress: { wp_site_id, status } | null, google: { search_console, analytics, connect_url? }, briefing: {week_of, headline, open_offers} | null }], next_step? }. latest_audit is the newest completed audit linked to the site; null does not rule out check_brand_citation / get_share_of_voice audits for the domain, which carry no site link but which get_fix_plan also uses. report_url is a public report of that audit to give the user. wp_site_id is the site_id the wp_* tools take. google says whether query_search_console / query_google_analytics will work for the site; when either is false, give the user connect_url (a one-time Google sign-in in the browser). An empty list means the workspace has no sites yet: call add_site with the user's domain.

Surface the AI-engine prompts where competitor domains were URL-cited in this site's audit history but the site was NOT — for one competitor, or every competitor on the site at once. Covers the site's audits and those run through the MCP for its domain (check_brand_citation, get_share_of_voice, rechecks). Billing: 5¢ per call — one run whether it covers one competitor or all of them. Not billed when the site_id or competitor_domain is rejected, the scan fails, or the window has no answered checks to scan (total_prompts_scanned 0, charged_cents 0). When to call: 'what is <competitor> getting cited on that we're not', 'where are we losing to <competitor>', 'which competitors beat us in AI answers'. For every competitor, omit competitor_domain rather than calling once per competitor. Inputs: site_id (from list_sites); competitor_domain — optional, one of the site's competitor_domains (list_sites shows them); window_days — optional, default 30 (7–365). Returns with competitor_domain: { rows: [{prompt, engines_competitor_cited_on, last_cited_at, leverage}], total_prompts_scanned, competitor_domain, window_days, generated_at, charged_cents }. Without it: { competitors: [{competitor_domain, prompts_won, high_leverage, engines}] ranked by prompts_won, rows: [{prompt, competitors_cited, competitor_count, engines_competitor_cited_on, last_cited_at, user_brand_mentioned, leverage}] widest losses first, competitor_domains, total_prompts_scanned, window_days, generated_at, charged_cents }. leverage: 'high_leverage' when the brand was named in the answer but not URL-cited (closest gap to close), 'pure_loss' when neither. A competitor_domain not on the site returns competitor_not_on_site with valid_competitor_domains. Example: { site_id: "...", competitor_domain: "asana.com", window_days: 30 } — or { site_id: "..." } for all competitors.

Turn on, change or pause recurring citation monitoring for a site: AuditAE re-asks its buyer questions on ChatGPT, Perplexity, Gemini and Google AI Overviews every week (or month), keeps every answer, and emails the account owner when the brand gains or loses a citation. Read what moved with get_changes (free). One schedule per site — the same one as the dashboard's "Track weekly"; calling again updates it. Billing: free to schedule; when it runs, 5–12¢ per engine check for each question × engine answered, plus a fix-it playbook for each answered check that didn't cite the brand, billed on LLM usage (about 12¢ each), plus about 45¢ for the audit rollup, plus a 25¢ saved report per run. cost_per_run_cents is the estimate (checks exact, the rest about); say it and the monthly estimate to the user and call only after they agree. A run that finds the workspace out of credit pauses the schedule. Inputs: site_id — from list_sites; or domain instead. prompts — buyer questions to watch (max 25); they become the site's tracked questions. Omit to keep the site's own (or its latest audit's). engines — optional; default the four core engines (ai-mode is opt-in, 10¢/check). cadence — weekly (default) | monthly. paused — true pauses it (history kept), false resumes. Returns { monitor_id, site_id, domain, status: active|paused, cadence, next_run_at, prompts, engines, created, checks_per_run, cost_per_run_cents, cost_breakdown_cents, monthly_estimate_cents, next_step }. Runs happen on the daily 06:00 UTC pass. Example: { site_id: "…", prompts: ["best invoicing app for freelancers"], cadence: "weekly" }

Shrink images for page speed: fetch each one as the Site Audit crawler does, resize it to max_width (never enlarging), compress it to WebP (or keep its type, with format "original" and by default where the file is replaced in place) and step it down toward the 200 KB large_images limit without visible loss. Returns a private download link (48 h) per image, the size before and after, and a paste-ready <img> tag. Billing: 1¢ per 5 images optimized (rounded up per call); free when an image saves under 10 KB or 10%, for errors and skipped files, and for the same image and settings again within 24h. Returns charged_cents. 300 images an hour per workspace. When to call: after get_crawl_issue(large_images) — pass site_id to optimize the crawl's images over 200 KB, largest first — or with urls for any public image (CDN images the crawl counts as external too). Inputs: urls — 1–20 image URLs. Or: site_id — the AuditAE site id (from list_sites): its latest crawl's large_images. run_id — optional crawl run; limit (default 10, max 20) and offset (pass next_offset). max_width — 320–3840, default 1920. format — webp or original (same type and file name, for site builders with fixed URLs). Default webp; original on a WordPress site, for /wp-content/uploads/ images and next/image or i0.wp.com sources. quality — 40–95, the starting lossy quality. Returns: { items: [{ url, source_url?, status: optimized|optimized_still_over_limit|already_optimized|skipped|failed|not_processed, reason?, before, after, saved_bytes, saved_pct, quality_used, browsers_receive?, download_url?, filename, expires_at, snippet?, references_to_update, referrers?, billed, repeat_free? }], totals, charged_cents, next_offset?, note, next_step }. Follow next_step to put the files in place, then submit_urls and crawl_site to confirm. SVG and animated images (GIF, WebP, APNG) are skipped. Up to 45 s per call; unfinished images come back not_processed (free): call again.

Fetch one page (a domain's homepage, or `url`) and report its meta tags, JSON-LD schema types, headings, robots.txt (sitemaps, and which AI crawlers like GPTBot, ClaudeBot, PerplexityBot, Google-Extended it blocks site-wide), whether /llms.txt is served, and Core Web Vitals from PageSpeed Insights (PSI), mobile and desktop. Billing: 2¢ per page after 3 free pages a day; a page already audited today (incl. the PSI re-poll) or that didn't load is free. For many pages of one site crawl_site (1¢ per 10 pages, one call) is cheaper. 30 calls/hour per target host. When to call: 'audit my site', 'check schema/meta on <url>', 'is the page fast', or to re-check a page after an edit. Inputs: domain — hostname or URL (fetches its homepage). url — optional exact URL instead (kept as given; ports other than 80/443 refused). include_pagespeed — default true; false answers in seconds. refresh_pagespeed — default false; true ignores cached Core Web Vitals. Timing: ~25 s. A PSI strategy not finished by then comes back "pending" and keeps measuring — call again with the same domain/url in ~1 minute. Readings are cached 10 min (errors 2). Returns: { url, final_url, redirected, fetched_at, response_status, fetch_error, meta, schema_types, headings: { h1Count, h1Texts, h2Count, ordered, firstSkip }, robots: { found, status, sitemaps, ai_crawlers: { allowed, blocked, fix } | null }, llms_txt: { url, found, status, problem }, pagespeed: { mobile, desktop } | null, pagespeed_note?, bot_protection?, billing: { charged_cents, free_pages_per_day, free_pages_used_today, price_after_cents }, suggested_next, next_step }. bot_protection (page refused us): relay its note. Each strategy: { status: ok|error|pending, measuredAt, fromCache, score (0–100), lcpSec, inpMs, inpSource, clsUnitless, fcpSec, ttfbSec, tbtMs, fetchedUrl, error }. inpMs is real-user CrUX p75 (inpSource field_url or field_origin; null if neither); the rest are lab values from one Lighthouse run.

Turn on, change or stop a site's automatic re-crawl: weekly on a weekday or monthly on a day (1–28), at a fixed hour between 05:00 and 10:00 UTC. Each run crawls up to max_pages like crawl_site, scores it, compares it with the crawl before (compare_crawls reads the diff) and emails the owner a summary: Site Health change, new and fixed issues. One schedule per site; calling again changes it, and resumes a paused one. Billing: free to schedule; when it runs, 1¢ per 10 pages fetched, billed as each run crawls; a run that hits a zero balance pauses the schedule. Say max_cost_per_run_cents and monthly_estimate_cents to the user (omit cadence, or pass dry_run: true, to get them without changing anything) and turn it on only after they agree. Inputs: site_id — the AuditAE site id (from list_sites). cadence — weekly | monthly | off (off deletes the schedule; past crawls stay). Omit to read the schedule and the quote. weekday — weekly: monday … sunday. Default: the current one, else monday. day_of_month — monthly: 1–28. Default: the current one, else 1. max_pages — per run, 1–10,000. Default: the current one, else 1.2 × the last whole-site crawl or the URL list's size, else 10,000. notify — email the owner after each run. Default true. dry_run — true: quote and preview the schedule; nothing changes. Crawl settings (source, urls, include, exclude, …) as in crawl_site: kept for every run, on top of the site's defaults. Returns: { site_id, domain, schedule: { cadence, weekday, day_of_month, run_hour_utc, max_pages, notify, next_run_at, paused, paused_reason, last_run_id, last_run_at, last_skip_reason, settings?, url_count? } | null, cost_per_run_cents (at the last crawl's size), max_cost_per_run_cents, monthly_estimate_cents, last_crawl_pages (null: none, or capped at its max_pages), rejected? (listed URLs not kept), created?, resumed?, stopped?, dry_run?, note }. paused_reason out_of_credits: top up (create_top_up_link), then call again with the cadence to resume.

Schedule a one-time re-run of prompts for a site, N days from now, to see whether published fixes got the brand cited — typically get_fix_plan's verify_prompts, with its audit_id as the baseline. Nothing runs or bills now. Billing: free to schedule; when it runs, 5–12¢ per engine check (33¢ per prompt on the four default engines, ai-mode 10¢) for each prompt × engine answered, plus a fix-it playbook for each answered check that didn't cite the brand, billed on LLM usage (about 12¢ each), plus about 45¢ for the audit rollup. estimated_cost_cents covers the checks only. If credit runs short then, only the checks the balance covers run and get_recheck reports out_of_credits. Limits: at most 25 rechecks waiting to run per workspace, 25 prompts each; cancel_recheck removes one before it fires. When to call: after the user has published fixes, to learn later whether AI engines now cite or mention the brand (engines take days to weeks to pick up a change; for an answer now use check_brand_citation). Inputs: site_id — from list_sites; or domain instead. prompts — e.g. the plan's verify_prompts. Omit to re-ask the baseline audit's prompts (25 or fewer). days — 1–90, default 14. engines — optional; defaults to the four core engines, ai-mode is opt-in. baseline_audit_id — e.g. get_fix_plan's audit_id. Default: the site's newest completed audit that asked these prompts. label — optional note shown with it. When it fires: the daily scheduler (06:00 UTC) runs one fresh audit (no cached answers) on its first pass at or after run_at, once; no email or saved report — read it with get_recheck. Returns { recheck_id, status: "scheduled", site_id, domain, label, run_at, prompts, engines, checks, baseline: {audit_id, completed_at} | null, prompts_without_baseline, estimated_cost_cents, charged_cents: 0, note? }. prompts_without_baseline get an after-only result. Example: { site_id: "…", prompts: ["best invoicing app for freelancers"], baseline_audit_id: "…" }

Submit new or changed URLs on one of the org's sites to IndexNow (api.indexnow.org), which notifies Bing, Yandex, Naver and Seznam so they can re-crawl them sooner (each engine decides when; not a guarantee of indexing). Google doesn't use IndexNow. Bing's index is one of the sources ChatGPT search and Copilot retrieve from. Sent from AuditAE's server. Billing: free. At most 30 calls per hour per org that reach the key-file check. When to call: after changed pages are live on a site that isn't a paired WordPress site (the AuditAE plugin already pings IndexNow on publish/update unless its auto-ping is off). Submit only URLs that changed: IndexNow throttles hosts that resubmit unchanged URLs. Inputs: site_id — the AuditAE site id (from list_sites). urls — 1–100 paths ("/pricing") or absolute URLs on the site's domain or its www variant. Duplicates and #fragments are dropped, other hosts rejected. key_location — optional URL of an IndexNow key file the site already serves (Rank Math's, or the AuditAE plugin's "Key file" under Settings → AuditAE → AI Crawlers). Omit to use AuditAE's key for this site. Key file: IndexNow only accepts URLs when the host serves the key at https://<host>/<key>.txt. If it isn't served, nothing is submitted and the answer is status "key_file_missing" with the filename and contents to publish; publish it, then call again. Returns: { status: "submitted" | "not_accepted", site_id, host, key_location, submitted_urls, rejected: [{ input, reason }], duplicates_removed, batches: [{ host, url_count, http_status, ok, meaning, response }] } (http_status 200 accepted; 202 accepted, key check pending; 403 key file missing or wrong; 422 URLs don't match the host; 429 slow down) | { status: "key_file_missing", key_file: { url, filename, contents, content_type }, found, how_to_fix, wordpress? } | { status: "no_valid_urls", rejected } | { error: "site_not_found" | "rate_limited" }.

Check a schema.org JSON-LD object before it ships: the top-level node, every @graph node, and the nested items engines read (FAQPage Question/acceptedAnswer.text, BreadcrumbList ListItem position/name/item, HowTo steps, Product offers/aggregateRating/review, addresses). Each issue has a property path such as mainEntity[0].acceptedAnswer.text. Billing: free — local check, no network, no LLM tokens. Types: Article, BlogPosting, HowTo, FAQPage, Product, Organization, BreadcrumbList, WebSite, SoftwareApplication, Service, LocalBusiness, WebPage, Person, and their subtypes (NewsArticle, Corporation, Plumber, WebApplication…). @type arrays use the first known type; a wrong-case @type gets a 'did you mean' and is still checked. Checks: @context must be schema.org (http/https, trailing slash, array or @vocab object all fine); URLs must be absolute with a real domain (no relative paths or @handles); ISO 8601 dates and durations; availability/itemCondition enums; ISO 4217 currencies; plain-number prices; Product needs offers, review or aggregateRating. Misspelled properties (e.g. adress) are warnings. When to call: before every wp_set_post_schema / wp_set_organization_schema / wp_set_faq_schema write, and on any hand-edited JSON-LD. generate_schema already returns this result. Returns: { valid, type, checked_types, issues: [{ severity: error|warning|info, property, message }], suggestions, suggested_next?, next_step? } (suggested_next: a valid Organization or WebSite node with one paired WordPress site → wp_set_organization_schema, priced). Fix every error and re-validate before writing. Each message says whether a requirement comes from Google's rich-result guides or from AuditAE (schema.org itself requires nothing). Suggestions are optional properties with the reason each matters.