Geo MCP Server

DigestSEO — AI Visibility MCP for SEO & GEO

Quick Install

Runs locally over stdio with your own API keys — all data stays on your machine (see Privacy Policy). Set at least one engine key (OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, PERPLEXITY_API_KEY, XAI_API_KEY, SERPAPI_API_KEY); engines without a key skip gracefully.

Runtime: Node.js 22.13+ (CI exercises Node 22 and 24).

Claude Desktop / any MCP client (npx):

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"],
      "env": {
        "OPENAI_API_KEY": "sk-...",
        "GEMINI_API_KEY": "your_key_here"
      }
    }
  }
}

ChatGPT (remote MCP): ChatGPT does not connect directly to local STDIO MCP servers. For ChatGPT, use the self-hosted remote MCP setup below, or the OpenAI Secure MCP Tunnel setup for a server running on a local/private machine. The public geo-mcp.digestseo.com/mcp endpoint is not a turnkey no-key fresh-scan service.

Perplexity Computer (remote MCP): Perplexity Computer supports custom remote MCP connectors on eligible plans. After self-hosting mcp-geo, open Account settings > Connectors > + Custom connector, choose Remote, name it digestseo, and enter your own deployment's https://<worker-host>/mcp URL. Use the connector's OAuth option for the Worker flow; if you configured CONNECT_SECRET, complete that browser gate during connection. Do not use the public geo-mcp.digestseo.com/mcp endpoint as a turnkey no-key scan service. See Perplexity's current Computer connector guidance.

Replit Agent (remote MCP): after self-hosting mcp-geo, open Integrations -> MCP Servers for Replit Agent -> Add MCP server, name it digestseo, and enter your own deployment's https://<worker-host>/mcp URL. Choose the OAuth flow when prompted: Replit supports OAuth dynamic client registration (DCR), which the self-hosted Worker exposes through its standard discovery and registration endpoints. Select Test & Save, then complete the browser authorization step; if you configured CONNECT_SECRET, enter it in that gate. Replit supports remote HTTPS MCP servers rather than this package's local stdio process, so use your configured Worker URL and do not treat the public geo-mcp.digestseo.com/mcp endpoint as a turnkey provider-key service. See Replit's current MCP guide.

Claude Code:

claude mcp add --transport stdio digestseo -s user --env GEMINI_API_KEY=your_key_here -- npx -y @digestseo/mcp-geo

Or install the same local MCP integration through this repository's owner-controlled Claude Code marketplace:

/plugin marketplace add AKzar1el/mcp-geo
/plugin install digestseo-geo@digestseo-mcp

The marketplace plugin uses the repository's .mcp.json to launch npx -y @digestseo/mcp-geo. Zero provider keys are enough for tool discovery; for engine-backed scans, make only the provider keys you want available to the Claude Code process. The direct claude mcp add command above remains the simplest option when you want to attach provider keys explicitly to the server configuration.

Codex CLI:

codex mcp add digestseo -- npx -y @digestseo/mcp-geo

The zero-key command is enough for tool discovery. Add only the provider keys you want with repeated --env NAME=VALUE options before the -- when engine-backed scans are needed.

Amp CLI:

amp mcp add digestseo -- npx -y @digestseo/mcp-geo

Amp runs this as a local STDIO MCP server. The zero-key command is enough for tool discovery; before engine-backed scans, make only the provider keys you want available to the Amp process or configure them in Amp's local MCP env settings instead of committing secrets. See Amp's current MCP guide.

OpenCode v2:

opencode mcp add digestseo --global -- npx -y @digestseo/mcp-geo

OpenCode v2 runs this as a local STDIO server. Omit --global for project-only configuration. Zero keys are enough for MCP tool discovery. For engine-backed scans, edit the generated OpenCode v2 config and add only the provider variables you want under mcp.servers.digestseo.environment, mapping each to an environment reference such as "OPENAI_API_KEY": "{env:OPENAI_API_KEY}"; keep the actual secret value in the process environment rather than in the config file. Verify the connection with opencode mcp list. See the current OpenCode v2 MCP guide.

Mistral Vibe Code: add mcp-geo to the user-level ~/.vibe/config.toml or project-level ./.vibe/config.toml:

[[mcp_servers]]
name = "digestseo"
transport = "stdio"
command = "npx"
args = ["-y", "@digestseo/mcp-geo"]

The zero-key entry is enough for tool discovery. For engine-backed scans, pass only the provider keys you want through Vibe's STDIO environment configuration or the environment inherited by Vibe instead of committing secrets. Use /mcp digestseo (or /mcp) in Vibe to verify the server and tools. See Mistral's current MCP server guide and Vibe configuration reference.

LibreChat: add mcp-geo to librechat.yaml as a local STDIO server:

mcpServers:
  digestseo:
    type: stdio
    command: npx
    args:
      - -y
      - '@digestseo/mcp-geo'

Restart LibreChat after changing librechat.yaml. The zero-key entry is enough for MCP tool discovery. Before engine-backed scans, expose only the provider API keys you intend to use to the LibreChat process rather than committing secret values into the YAML file. See LibreChat's current MCP configuration guide and MCP feature guide.

AnythingLLM: add mcp-geo from Settings -> Agent Configuration -> MCP, or merge this entry into anythingllm_mcp_servers.json in AnythingLLM's storage plugins directory:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

AnythingLLM treats command-backed servers as local STDIO MCP servers and can start them when an agent needs their tools. The zero-key entry is enough for MCP discovery; before engine-backed scans, add only the provider environment variables you intend to use through AnythingLLM's MCP configuration or the process environment instead of committing raw secrets. See AnythingLLM's current MCP compatibility guide.

Langflow: open Settings -> MCP Servers (or the MCP sidebar -> Add MCP Server), choose STDIO, name the server digestseo, set Command to npx, and add Arguments -y and @digestseo/mcp-geo. The zero-key server is enough for MCP tool discovery; before engine-backed scans, add only the provider keys you intend to use in Langflow's MCP Environment Variables fields rather than storing raw secrets in a flow. Then select the saved server from an MCP Tools component and connect its tools to a Langflow Agent. If Langflow itself runs in Docker, its image must include Node.js before it can launch an npx server. See Langflow's current MCP client guide.

Flowise: for a local/self-hosted Flowise instance, add a Custom MCP tool to an Agent and use STDIO with {"command":"npx","args":["-y","@digestseo/mcp-geo"]}. Refresh Available Actions to load the twelve mcp-geo tools. Zero provider keys are enough for discovery; before engine-backed scans, make only the provider keys you intend to use available to the Flowise process/service environment. Flowise explicitly recommends STDIO only when it is running locally rather than in a cloud service because the npx package is launched on the Flowise host. See Flowise's current Tools & MCP guide.

Kilo Code: open Settings -> Agent Behaviour -> MCP Servers, add a Local (stdio) server named digestseo, and launch npx with arguments -y and @digestseo/mcp-geo. The equivalent macOS/Linux kilo.jsonc entry is:

{
  "mcp": {
    "digestseo": {
      "type": "local",
      "command": ["npx", "-y", "@digestseo/mcp-geo"],
      "enabled": true
    }
  }
}

On Windows, Kilo's current guidance uses "command": ["cmd", "/c", "npx", "-y", "@digestseo/mcp-geo"]. Zero provider keys are enough for discovery. Before engine-backed scans, add only the provider keys you intend to use through Kilo's MCP environment settings or the local process environment, and keep raw secrets out of project-level kilo.jsonc. See Kilo Code's current MCP configuration guide and CLI MCP guide.

Google Antigravity: Antigravity 2.0, Antigravity CLI, and Antigravity IDE can launch custom local STDIO MCP servers. In the IDE, open the agent panel -> MCP Servers -> Manage MCP Servers -> View raw config; from the CLI, /mcp opens the interactive MCP manager. Add digestseo to the global ~/.gemini/config/mcp_config.json or a workspace .agents/mcp_config.json:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

The zero-key configuration is enough for MCP tool discovery. Before engine-backed scans, expose only the provider keys you intend to use through the local server environment; if you use workspace .agents/mcp_config.json, keep raw secrets out of any shared or committed copy. See Google's current Antigravity MCP guide.

Cherry Studio: open Settings -> MCP -> MCP Servers -> Add, choose STDIO, name the server digestseo, set Command to npx, and add Arguments -y and @digestseo/mcp-geo. The zero-key server is enough for MCP tool discovery. Before engine-backed scans, add only the provider keys you intend to use in Cherry Studio's MCP environment-variable fields rather than putting secrets in prompts or screenshots. Enable the server, inspect its Tools, then bind it to the intended Agent under Work -> Agent -> Edit -> MCP. See Cherry Studio's current official MCP configuration guide and MCP workflow guide.

Raycast AI: open Install MCP Server (or Manage MCP Servers -> Install New Server), choose Standard Input/Output, set Command to npx, and set Arguments to -y and @digestseo/mcp-geo. The zero-key install is enough for tool discovery. Before engine-backed scans, add only the provider keys you want in Raycast's MCP Environment fields rather than hard-coding them into shared project files. Restart Raycast if npx was added to PATH after Raycast started. See Raycast's current MCP manual.

Msty Studio: open Toolbox -> Add New Tool, choose STDIO / JSON, and use:

{
  "command": "npx",
  "args": ["-y", "@digestseo/mcp-geo"]
}

The zero-key tool is enough for MCP discovery. For engine-backed scans, define only the provider keys you want in Msty Studio Environments and attach them to the tool rather than storing raw secrets in shared files. Msty Studio Desktop can run the tool locally; Studio Web needs its documented Desktop/Sidecar connection for local MCP tools. See Msty Studio's current Toolbox MCP guide and environment guide.

Jan Desktop / Jan Agent: in Jan Desktop open Settings -> MCP Servers -> + Add MCP Server, choose STDIO, set Command to npx, and add Args -y and @digestseo/mcp-geo. The zero-key server is enough for tool discovery; add only the provider keys you intend to use through Jan's MCP Env fields. Jan Agent reads the same MCP configuration, or you can add it from the terminal with jan cli mcp add digestseo --command npx --arg -y --arg @digestseo/mcp-geo and then enable it. If you run Path B on your own Worker, Jan also supports HTTP MCP servers at https://<worker-host>/mcp and handles advertised OAuth with metadata discovery, dynamic client registration, and authorization-code + PKCE. Do not present the public DigestSEO endpoint as a turnkey provider-key service. See Jan's current MCP server guide and Agent MCP guide.

Zed: open Settings -> AI -> MCP Servers, choose Add Server -> Add Local Server, and configure digestseo with command npx and arguments -y, @digestseo/mcp-geo. The zero-key local server is enough for tool discovery; for engine-backed scans, add only the provider keys you intend to use in Zed's local MCP env map rather than committing secrets into shared project settings. If you run Path B on your own Worker instead, choose Add Remote Server and use https://<worker-host>/mcp; when no Authorization header is configured, Zed uses the standard MCP OAuth flow. Do not treat the public DigestSEO endpoint as a turnkey provider-key service. See Zed's current MCP guide.

TraeCode: open Settings -> MCP -> Add -> Manually add and paste this local STDIO configuration, or save the same mcpServers object as .trae/mcp.json in a trusted project:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

TraeCode recommends NPX/UVX for local MCP servers and supports env values when engine-backed scans need provider keys. The zero-key form is enough for discovery; keep raw provider secrets out of project-level .trae/mcp.json. TraeCode CLI can also load that project-level MCP file, or you can add an equivalent stdio entry through traecli config edit and inspect it with /mcp. See TraeCode's current IDE MCP setup and CLI MCP guide.

Qwen Code: this repository already ships the portable Agent Plugins v1 metadata that Qwen Code can load directly from GitHub:

qwen extensions install AKzar1el/mcp-geo

Or add only the local MCP server as a user-scoped STDIO entry:

qwen mcp add --scope user digestseo npx -y @digestseo/mcp-geo
qwen mcp list

Qwen Code natively supports Agent Plugins v1, including the repository's root plugin.json + mcp.json, so the extension path reuses the same npx -y @digestseo/mcp-geo server without another wrapper. Direct MCP configuration is stored in ~/.qwen/settings.json; project-scoped servers can instead live in .qwen/settings.json under mcpServers. The zero-key setup is enough for tool discovery. Before engine-backed scans, expose only the provider variables you intend to use to the Qwen process, or reference existing environment variables from the MCP env map instead of committing raw keys to project settings. Start Qwen Code and run /mcp to verify the server and tools. See Qwen Code's current extension guide and MCP server guide.

Augment Code / Auggie: in the Augment extension for VS Code or JetBrains, open Settings -> MCP servers and use Import from JSON with:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

For Auggie CLI, the equivalent user-level install is:

auggie mcp add digestseo -- npx -y @digestseo/mcp-geo
auggie mcp list

Auggie persists MCP servers in ~/.augment/settings.json; run /mcp in an Auggie session to inspect them. The zero-key setup is enough for tool discovery. Before engine-backed scans, add only the provider keys you intend to use through Augment's MCP environment fields or Auggie's --env NAME=VALUE option rather than committing raw secrets. If the twelve local tools consume too much agent context, Augment's optional MCP Tool Search can load tool schemas on demand. See Augment's current MCP setup guide and Auggie integrations/MCP guide.

GitHub Copilot CLI:

copilot mcp add digestseo -- npx -y @digestseo/mcp-geo

The base install starts with zero provider keys so tool discovery works. Add only the engine keys you want with Copilot CLI's --env NAME=VALUE option before running scans.

GitHub Copilot cloud agent / code review: repository administrators can also add mcp-geo under Settings -> Copilot -> MCP servers. Use the local npm package rather than the hosted OAuth endpoint, because Copilot cloud agent and code review do not currently support remote MCP servers that rely on OAuth.

Start with a conservative read-only profile because repository MCP tools can run autonomously:

{
  "mcpServers": {
    "digestseo": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"],
      "tools": [
        "check_visibility",
        "get_visibility_history",
        "compare_competitors",
        "get_citations",
        "list_brands",
        "list_prompts"
      ]
    }
  }
}

Copilot code review only accepts tools whose MCP metadata marks them read-only; the tools above already publish readOnlyHint: true. This profile is useful when the task has access to an mcp-geo local database created during that run. For a task that should create/refresh visibility data, explicitly add only the mutating tools you intend to permit (for example track_brand and refresh_brand) and remember that refresh_brand can make billable provider calls.

Provider credentials belong in Copilot Agents secrets/variables, not in repository JSON. GitHub only exposes names prefixed COPILOT_MCP_; map a selected secret into mcp-geo with env, for example "OPENAI_API_KEY": "$COPILOT_MCP_OPENAI_API_KEY". See GitHub's current repository MCP configuration guide.

Portable Agent Plugin (GitHub Copilot / VS Code / Kiro and other Agent Plugins 1.0 clients): this repository now ships the standard root plugin.json + mcp.json pair. GitHub Copilot CLI can install it directly from GitHub:

copilot plugin install AKzar1el/mcp-geo

In VS Code, run Chat: Install Plugin from Source and enter https://github.com/AKzar1el/mcp-geo. In Kiro, use Powers -> Add Custom Power -> Import power from GitHub with the same repository URL. The portable plugin launches npx -y @digestseo/mcp-geo; zero provider keys are enough for discovery, while engine-backed scans inherit only the provider keys you intentionally make available to the host client. Existing native install paths above remain valid.

Qoder CLI:

qoder mcp add digestseo -- npx -y @digestseo/mcp-geo
qoder mcp list

Qoder launches this as a local STDIO MCP server. The zero-key command is enough for tool discovery; make only the provider keys you want available to the Qoder process before engine-backed scans. If Qoder is already running, use /mcp reload to rediscover the server and tools. See Qoder's current MCP server guide and MCP reference.

Docker Agent: Docker Agent can launch local STDIO MCP servers directly from agent YAML. Add this toolset to the agent that should use mcp-geo:

toolsets:
  - type: mcp
    command: npx
    args: ["-y", "@digestseo/mcp-geo"]

The zero-key form is enough for tool discovery. For engine-backed scans, add only the provider keys you need under the toolset's env: map (Docker Agent supports ${env.NAME} expansion) instead of committing secret values. See Docker's current local MCP tool documentation.

goose: add mcp-geo as a local STDIO extension in ~/.config/goose/config.yaml (macOS/Linux) or %APPDATA%\Block\goose\config\config.yaml (Windows):

extensions:
  digestseo-geo:
    type: stdio
    name: digestseo-geo
    enabled: true
    cmd: npx
    args: ["-y", "@digestseo/mcp-geo"]
    timeout: 300

The zero-key extension is enough for tool discovery. Before engine-backed scans, configure only the provider environment variables you want for this extension through goose's extension settings / secret storage instead of putting raw API keys in the YAML file. The same server can also be added interactively with goose configure -> Add Extension -> Command-Line Extension. See goose's current extension setup and configuration reference.

GitLab Duo CLI: current GitLab Duo CLI releases can consume Claude-compatible plugin marketplaces directly. Register this repository and install the existing digestseo-geo plugin:

glab duo plugin marketplace add https://github.com/AKzar1el/mcp-geo.git
glab duo plugin install digestseo-geo@digestseo-mcp

The installed plugin loads the same local npx -y @digestseo/mcp-geo MCP server from .mcp.json. Zero provider keys allow discovery; make only the provider keys you want available to the GitLab Duo CLI process before engine-backed scans.

Factory Droid:

droid mcp add digestseo "npx -y @digestseo/mcp-geo"
droid mcp list

Droid runs this as a local STDIO MCP server. The zero-key install is enough for tool discovery; add only the provider keys you choose in Droid's user-level MCP configuration before engine-backed scans. Keep provider secrets out of project-level .factory/mcp.json files.

Amazon Q Developer (IDE): open the Q Developer chat panel ? Tools ? +, choose STDIO, name the server digestseo, set Command to npx, and add Arguments -y and @digestseo/mcp-geo. Add only the provider environment variables you want before running scans; zero keys still allow MCP tool discovery.

Amazon Q Developer CLI: add the same local STDIO server through Q's native MCP manager:

q mcp add --name digestseo --command npx --args '["-y", "@digestseo/mcp-geo"]'
q mcp list

The zero-key server is enough for MCP tool discovery. Before engine-backed scans, add only the provider variables you intend to use to the Q CLI MCP configuration instead of committing secrets to the repository. Amazon Q Developer CLI supports local process-backed MCP servers and manages them through q mcp; use /tools inside a Q session to inspect the tools that loaded. See AWS's current Amazon Q Developer MCP guide and CLI MCP configuration reference.

JetBrains AI Assistant (IDE): open Settings > Tools > AI Assistant > Model Context Protocol (MCP) > Add, choose STDIO, and use:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

JetBrains AI Assistant supports local STDIO and NPX MCP servers. The zero-key form is enough for tool discovery; before engine-backed scans, make only the provider keys you want available to the IDE process, or import an already-configured Claude MCP server.

JetBrains Junie (CLI / IDE): run /mcp in Junie CLI to open the MCP Installation Assistant. You can search the Official MCP Registry for mcp-geo, or add the local server manually in .junie/mcp/mcp.json for one project or ~/.junie/mcp/mcp.json for your user:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

Junie CLI and the Junie IDE plugin use the same MCP configuration. The zero-key server is enough for tool discovery; before engine-backed scans, make only the provider keys you intend to use available to the Junie process and keep raw secrets out of a shared or committed project .junie/mcp/mcp.json. Use /mcp to verify the active server and tools. See JetBrains' current Junie CLI MCP guide and Junie IDE MCP settings.

JetBrains Air: this repository already ships the standard root .mcp.json that launches npx -y @digestseo/mcp-geo. In Air, open Settings > AI > MCP Servers, enable MCP support and Launch workspace MCP servers, then use the Workspace scope so Air reuses that checked-in file. The repository config contains no provider secrets and is sufficient for zero-key tool discovery. Engine-backed scans still require the selected provider keys in the local server process environment; keep them out of committed .mcp.json. See the JetBrains Air MCP server guide.

Visual Studio 2022 17.14+ / Visual Studio 2026: Visual Studio uses its own servers-shaped MCP configuration. Create %USERPROFILE%\.mcp.json for a user-wide install or <SOLUTIONDIR>\.mcp.json for one solution:

{
  "servers": {
    "digestseo": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

Open GitHub Copilot Chat in Agent mode and use the Tools menu to verify digestseo is available. Zero provider keys are enough for tool discovery; before engine-backed scans, make only the provider keys you want available to the Visual Studio process rather than committing secrets into the solution file. See Microsoft's current Visual Studio MCP setup.

Cursor:

Windsurf: open Manage MCPs → View raw config and add the local stdio package:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"],
      "env": {
        "OPENAI_API_KEY": "sk-..."
      }
    }
  }
}

Use only the provider keys you want; zero keys still allow MCP tool discovery.

Roo Code: open MCP Servers > Edit Global MCP, or create .roo/mcp.json for a project-scoped install, and add:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

Roo Code supports local STDIO MCP servers. The zero-key form is enough for tool discovery; add only the provider keys you want before scans. On Windows, if Roo cannot launch npx directly, use "command": "cmd" with "args": ["/c", "npx", "-y", "@digestseo/mcp-geo"], matching Roo's documented Windows fallback.

VS Code: Install the local stdio server in VS Code. The base install starts with no provider keys so tool discovery works; add only the API keys you want in your VS Code MCP user configuration before running scans.

LM Studio: Add the local stdio server to LM Studio. The base install starts with no provider keys so tool discovery works; add only the API keys you want in LM Studio's mcp.json before running scans.

Kiro: for a one-click local install, or open the user MCP config (~/.kiro/settings/mcp.json) / workspace config (.kiro/settings/mcp.json) and add the local stdio package manually:

{
  "mcpServers": {
    "digestseo": {
      "command": "npx",
      "args": ["-y", "@digestseo/mcp-geo"]
    }
  }
}

Kiro supports local STDIO MCP servers across its current surfaces. The zero-key form is enough for discovery; add only the provider environment variables you want before engine-backed scans. For remote use, self-host the Worker below and configure your own deployed /mcp URL instead. The public geo-mcp.digestseo.com/mcp endpoint is not a turnkey no-key fresh-scan service.

Claude Desktop extension (one-click): download the .mcpb bundle from the latest release and double-click it — Claude Desktop prompts for the API keys.

First run: ask your client to "track acme.com as brand acme, then refresh it" — track_brand creates the brand with generated prompts, refresh_brand runs the first scan, check_visibility shows the scores.

AI agents installing this server: follow llms-install.md. Prefer a remote server with cron auto-refresh? Self-host on Cloudflare Workers below.

---

mcp-geo is an open-source AI visibility tracker that measures how often your brand is cited by ChatGPT, Claude, Perplexity, Gemini, Grok, Google AI Overviews, and Google AI Mode. It's the GEO (Generative Engine Optimization) and AEO (Answer Engine Optimization) equivalent of Google Search Console — built as an MCP server so you can query your AI visibility data directly inside ChatGPT through a configured remote MCP app, Claude.ai, Claude Desktop, Claude Code, GitHub Copilot CLI, Cursor, Codex CLI, or any MCP-compatible client.

Canonical product page: DigestSEO mcp-geo — AI Visibility MCP Server

Engineering case study: DigestSEO MCP Suite — AI visibility, Search Console, web validation, and trend intelligence

Need a client-ready baseline without running the stack yourself? The mcp-geo AI Visibility Audit is EUR 99 one time: one brand, up to three competitors, 20 buyer-intent prompts, checks across up to five supported AI surfaces where configured providers return usable results, citation evidence, and a prioritized action memo. The open-source package remains free.

See proof first: Open the sample report generated through mcp-geo to see the output style and evidence depth before requesting the audit.

Ready to request it? Open a prefilled email with your brand/domain and up to three competitors. No subscription or sales call is required.

Payment handoff: After fit and scope are confirmed, I reply with the normal invoice/payment instructions.

Methodology: The same 20 buyer-intent prompts are run as a point-in-time diagnostic and reported per engine, with citation/source evidence where available. The audit is an observed snapshot, not a proprietary ranking promise or guaranteed forecast.

Want the protocol before buying? Read the AI Visibility Audit methodology, including scope, engine coverage, interpretation limits, and what the audit does not claim.

Prefer zero setup? Try the hosted version at digestseo.com — managed Cloudflare infra, no API keys to manage, multi-brand, scheduled refresh, web UI. Waitlist now open. Join waitlist →

---

What it produces

Connect via MCP, ask Claude "Run an AI visibility analysis on [my brand]", and within 90 seconds you get a strategist-quality memo grounded in real per-engine data:

View the full report including content gaps, engine recommendations, and synthesis →

Want to reproduce the same evidence-first structure with your own data? Use the reusable AI Visibility Audit report prompt.

The report above was generated by Claude through the digestseo-mcp MCP server. The conversation chained five hosted tools — visibility.check, visibility.compare, visibility.citations (Perplexity + Claude), and visibility.content_gaps — to produce a 4-engine analysis with citation excerpts and a 3-recommendation strategy memo.

---

What's New

[0.3.26] - September 24, 2026

• OAuth 1.0 resource correctness: self-hosted Workers now bind OAuth grants and tokens to the canonical ${SELF_URL}/mcp resource required by @cloudflare/workers-oauth-provider 1.0.0, with deployment guidance that prevents resource-host mismatches.
• Broader coding-agent onboarding: Google Antigravity, JetBrains Junie, GitHub Copilot cloud agent/code review, Qwen Code, and Augment Code / Auggie now have first-party-aligned local MCP setup paths using the published npx -y @digestseo/mcp-geo package.

[0.3.25] - September 24, 2026

• Complete hosted safety metadata: all six hosted visibility tools now explicitly declare read-only, destructive, and open-world behavior for stricter MCP clients and plugin validators.
• Broader native onboarding: Langflow, Cherry Studio, Flowise, and Kilo Code setup now reuse the published local/self-hosted mcp-geo paths with zero-key discovery and secret-safe provider configuration.
• Stronger audit fulfillment: the reusable report prompt now turns the existing top_sources citation summary into recurring-source evidence before individual citation examples, without manufacturing derived metrics.

[0.3.24] - September 23, 2026

• Source-domain intelligence: get_citations / visibility.citations now summarizes the most frequently cited engine-native source domains across the requested window, with prompt counts, contributing engines, representative URLs, and tracked-brand-domain flags.
• Clear hosted MCP identity: modern SDK-v2 discovery now exposes the human-readable GEO Tracker title, concise description, and canonical product URL without changing the stateless transport contract.
• More native client onboarding: Replit Agent remote-MCP and Jan Desktop / Jan Agent setup now reuse the existing local or self-hosted mcp-geo paths without introducing another package or hosted turnkey-provider claim.

[0.3.23] - September 23, 2026

• Current Grok model: grounded Grok visibility scans now use xAI's current grok-4.7 model while preserving the existing Responses API, required Web Search grounding, and BYOK flow.
• AnythingLLM onboarding: MCP Management / anythingllm_mcp_servers.json setup now covers the published local stdio package with zero-key discovery and secret-safe optional provider configuration.
• Accurate Perplexity guidance: setup text now matches the already-shipped Agent API fast preset and points to live pricing instead of stale Sonar/fixed per-prompt wording.

[0.3.22] - September 23, 2026

• Perplexity retirement-safe: Perplexity scans now use the Agent API fast preset instead of the retiring fixed Sonar model selector, preserving grounded web-search visibility after the September 27 Sonar retirement.
• Current plugin discovery truth: portable Agent Plugin and Claude marketplace metadata now include Google AI Mode alongside the other supported AI-search surfaces.
• Amazon Q Developer CLI: native q mcp onboarding now covers the existing local stdio package with zero-key discovery and secret-safe provider configuration.
• Accurate self-hosting guidance: setup documentation now reflects the stateless SDK-v2 hosted MCP path and current manual-refresh scheduling behavior.

[0.3.21] - September 22, 2026

• Stateless hosted MCP: OAuth-protected /mcp traffic now uses Cloudflare's SDK-v2 createMcpHandler path with legacy stateless compatibility and explicit Host/Origin validation, while the old Durable Object binding remains only as a conservative migration hold.
• Leaner tool context: all twelve MCP tools now expose concise example-led descriptions and complete input-parameter guidance, reducing client context overhead and making tool selection clearer.

[0.3.20] - September 22, 2026

• Bounded provider requests: external AI-provider and SerpAPI calls now time out after 90 seconds instead of allowing a stalled upstream API to hang a scan indefinitely.
• Durable manual Worker scans: authenticated /admin/run-live requests can set wait_for_completion: true so manual/operator refreshes remain attached until service-binding engine work finishes.

[0.3.19] - September 22, 2026

Documentation truncated — see the full README on GitHub.