AuditAE SEO MCP Server

Hits DataForSEO's LLM Mentions corpus to return every observed AI prompt where a target shows up: the LLM answer, every cited source (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 — max prompts to return (default 50, max 100). Output: { report_id, url, title, target, platform, prompt_count, unique_domains_cited, charged_cents, prompts: [{question, answer_preview, sources: [{domain, url, position, publication_date}], ai_search_volume, monthly_trend}] } — saved as a kind="llm_mentions" site_report so users can revisit. 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 } — saved as a kind="web_mentions" site_report. Example: { site_id: "…", keyword: "Linear", page_type: "news" }

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, which reports whether answer-engine crawlers may crawl the site and whether /llms.txt is 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 }], blocked?, not_checked? }. Each failing check carries a copy-pasteable 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 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?}]}] }. 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. 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.

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, 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 }.

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"] }

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: "…" }

What moved for a site since the previous check: per buyer question and engine, where the brand gained or lost a citation (its URL among the AI answer's sources), and for a lost one which domains the engine cited instead and which competitors it named; plus tracked keywords that moved in Google. Compares the site's newest completed citation audit with the newest earlier one that asked 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 whether anything 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 and the user means the last full run. Returns { 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, next_step }. headline is a one-line summary to relay. Lists are capped at 25. Example: { domain: "acme.com" }

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?, 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).

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 }

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" }

Crawl 25 or 100 internal pages of a site breadth-first from its homepage and report per-page SEO data (title, meta description, canonical, H1s, schema, links, images, status, noindex) plus site-wide issues (broken pages, pages that couldn't be fetched, duplicate titles, missing meta, long redirect chains, mixed content, oversize pages, sitemap pages the crawl never reached). Billing: 1¢ per page fetched (25 pages = up to 25¢, 100 pages = up to 100¢); the balance must cover max_pages up front. Confirm max_pages with the user before calling. Different from run_technical_audit (one page, free). Takes ~30 s for 25 pages, ~2 min for 100; a crawl stops at 240 s and bills only the pages it fetched. Inputs: site_id — the AuditAE site id (from list_sites). Required. max_pages — 25 or 100. Required. seed_url — optional start URL on the same site; defaults to the homepage. Returns: { run_id, site_id, status: complete|partial|failed, seed_url, pages_crawled, pages_failed, skipped_by_robots, billed_cents, sitemap_files, issues_summary, top_problem_pages (up to 20, worst first), note }. issues_summary has exact counts and up to 10 samples per issue. Pages that couldn't be fetched are counted under fetch_errors / broken_links and never flagged for missing tags. get_latest_crawl re-reads the run later (free, paginated).

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 }] }, next_step }. The firewall probe uses the bots' user-agents, not their IP addresses: a block there is a strong hint, not proof (caveat says so).

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. 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 id. 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. 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, 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.

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 }

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." }

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, then schedule_recheck with verify_prompts and audit_id. Errors (unbilled; `message` says what to do): no_audit, nothing_to_fix, no_relevant_audit, nothing_left_to_fix (lists already_done), truncated and empty_plan (retry once), 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 }.

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 }. 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).

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 the most recent crawl_site run for a site: a compact issue rollup plus the pages that have issues, paginated. Billing: free — reads the stored run; nothing is fetched or re-crawled. Staleness: a run older than 30 days, or made before the crawler fixes of 2026-09-24, comes back with stale: true and a note — don't verify fixes against it; run crawl_site again. A run where every page failed reports status "failed". Issues are re-derived from the stored pages with today's rules (pages that weren't fetched are never flagged for missing tags). Inputs: site_id — the AuditAE site id (from list_sites). pages — 'issues' (default: only pages with an issue flag, worst first), 'all', or 'none' (rollup only). limit — pages per call, default 25, max 100. offset — default 0; pass next_offset from the previous answer for the next page. Returns: { site_id, run: { run_id, status, seed_url, started_at, completed_at, max_pages, pages_crawled, pages_failed, billed_cents, error_message, robots: { fetched, status, disallow, allow, sitemap_files }, sitemap_page_urls_total, sitemap_page_urls (first 20 page URLs listed in the sitemaps) }, stale, age_days, issues_summary: { broken_links, fetch_errors, missing_meta_description, missing_h1, … each { count, samples } }, pages_view, pages_total, offset, next_offset, pages: [{ url, final_url?, http_status, fetch_error?, depth, issue_flags, title, title_length, meta_description, h1_count, h1_first, canonical_url, canonical_matches, word_count, schema_types, … }], note? }. Tag fields are present only on pages that were fetched and parsed. { run: null } means the site was never crawled; { error: "site_not_found" } means the site_id is wrong.

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?, next_step }. 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.

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 or the scan fails. 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" }

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: "…" }

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: "…" }

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"] }

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"] }

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? } }], next_step? }. latest_audit is the newest completed audit linked to the site (dashboard, scheduled or keyless runs); 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.

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" }.

Fetch one page (a domain's homepage, or `url`) and report its meta tags (title/description/canonical/OG/Twitter), JSON-LD schema types, heading structure, robots.txt (declared sitemaps, and which AI crawlers such as GPTBot, ClaudeBot, PerplexityBot and Google-Extended it blocks site-wide), whether /llms.txt is served, and Core Web Vitals from Google PageSpeed Insights (PSI) for mobile and desktop. Billing: free; 30 calls per 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 https://<domain>/. url — optional exact URL to fetch instead (path, query and scheme kept as given; ports other than 80/443 are refused). include_pagespeed — default true; false answers in seconds. refresh_pagespeed — default false; true ignores cached Core Web Vitals (to verify a performance fix). Timing: answers within ~25 s. PSI often needs 20–60 s: a strategy not finished at ~22 s comes back status "pending" and keeps measuring — call again with the same domain/url in ~1 minute. Readings are cached 10 minutes per URL and strategy (errors 2); fromCache and measuredAt say so. 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?, 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 Chrome UX Report data (p75; inpSource field_url, or field_origin when the URL lacks traffic; null if neither); the other metrics are lab values from one Lighthouse run. ai_crawlers covers site-wide blocks (Disallow: /) only.

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. Inputs: amount_cents — whole cents, 500–100000 ($5–$1000). Example: { amount_cents: 2500 }

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 }. 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.