---
title: "Katman MCP: SEO and GEO tools for AI coding agents"
description: "Katman MCP runs in Cursor, Claude Code and VS Code: it scans your code, audits your live site like AI crawlers do and checks every fix. Audit Week: $3, 7 days."
url: https://katman.pro/mcp
lang: en
updated: 2026-09-30
---

Katman MCP · Audit Week $3 · Katman Pro

# Katman MCP: *the method as tools* for your AI coding agent

Katman MCP is a local MCP server you add to Cursor, Claude Code, VS Code, Windsurf, Codex CLI or Gemini CLI with one command. Its tools scan your codebase, audit your live site the way AI crawlers see it, measure whether ChatGPT, Claude, Gemini, Perplexity and Grok name you, and check that every fix was actually made. Every tool except katman\_account needs a Katman key: Audit Week ($3 once, for 7 days) unlocks the audit and recommendation tools, and Katman Pro adds the tools that build pages and files.

[Start with Audit Week: $3](https://katman.pro/app/login?next=%2Fapp%2Fbilling%3Fbuy%3Daudit_week) [Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=katman&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImthdG1hbi1tY3AiXSwiZW52Ijp7IktBVE1BTl9LRVkiOiIiLCJPUEVOUk9VVEVSX0FQSV9LRVkiOiIifX0=) [Install in VS Code](vscode:mcp/install?%7B%22name%22%3A%22katman%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22katman-mcp%22%5D%2C%22env%22%3A%7B%22KATMAN_KEY%22%3A%22%22%7D%7D)

macOS, Windows and Linux · needs Node.js 20 or later · every tool except katman\_account needs KATMAN\_KEY, which comes with Audit Week ($3 once, 7 days) or Katman Pro · all install options

## What it does, step by step

The book tells your AI coding tool what to do. Katman checks that it was done. Each step below lists the tools your agent calls and the file it leaves in your project’s .katman/ folder.

1.  Step 1

    ### Research

    What do your customers type into ChatGPT and Google, who do assistants recommend today, and what is your one sentence?

    tools: katman\_start · katman\_research · katman\_keywords · katman\_visibility\_run · katman\_manual\_check

    output: `.katman/research.md`

2.  Step 2

    ### Plan

    Katman reads your code and your live site the way AI crawlers do, then decides which pages to write, at which URLs, and what to fix first.

    tools: katman\_scan\_code · katman\_audit\_site · katman\_plan · katman\_page\_brief

    output: `.katman/plan.md`

3.  Step 3

    ### Build

    Your AI coding tool does the work one prompt at a time. Every task has an acceptance criterion; the next task waits until it passes.

    tools: katman\_prompt · katman\_generate · katman\_lint\_content

    output: `.katman/log.md`

4.  Step 4

    ### Verify

    Katman checks each criterion on the live site, tells Google, Bing and IndexNow what changed, and asks the same questions again 14 days later.

    tools: katman\_audit\_site · katman\_indexnow · katman\_report · katman\_setup\_monitoring

    output: `.katman/report.md`


## All 17 tools: Audit Week and Pro

Every tool returns plain Markdown for the agent plus structured data. Every tool except katman\_account needs KATMAN\_KEY: the 10 audit and recommendation tools run with Audit Week or Pro, and the 6 tools that build pages and files need Pro. Without the right plan, a tool explains what it needs instead of running. Read-only tools are marked read-only for your client, network tools are marked as such, and none of them is destructive.

| Tool | Plan | What it does | Network |
| --- | --- | --- | --- |
| Method |
| `katman_start` | Audit Week or Pro | Entry point. Reads .katman/, shows where you are in the four steps and gives the next step as an exact tool call. | none (local) |
| `katman_research` | Audit Week or Pro | Creates and updates research.md: your one sentence, the “not X” note, 10–12 customer situations, competitors with source and date, sourced proof, keywords and the 12+2 question set. | none (local) |
| `katman_plan` | Audit Week or Pro | Builds the page plan and the task list in the book’s 30-day order. Every task has a prompt code, an acceptance criterion and the tool that verifies it. | none (local) |
| `katman_prompt` | Pro only | Returns prompts P0–P14 filled with your research, each with Accept, Why and how Katman verifies it, plus notes for your framework. | none (local) |
| `katman_page_brief` | Pro only | A filled brief for a situation, comparison, pricing, FAQ, about, glossary, tool or home page: URL, title, first sentence, proof, not-for, FAQ, related pages and JSON-LD. | none (local) |
| `katman_generate` | Pro only | Generates robots.txt, llms.txt, JSON-LD, an AI-channel analytics snippet, a server-side bot counter and the IndexNow key file from your research. Writes them only with write: true. | none (local) |
| `katman_lint_content` | Audit Week or Pro | Checks a page against the content rules: the first sentences answer, the one sentence matches, no hype words or unsourced numbers, an update date, 5–8 FAQs, a not-for section, 3+ internal links. | your site (when given a URL) |
| `katman_report` | Audit Week or Pro | Writes report.md: research completeness, gate pass rates, visibility changes, top competitors and cited domains, plan progress, the top 10 open issues and the next 7 days. | none (local) |
| `katman_account` | No key needed | Shows your plan and its end date, the tools your key unlocks and how to connect a key. The one tool that works without a key. | katman.pro, only when KATMAN\_KEY is set |
| Crawl |
| `katman_scan_code` | Audit Week or Pro | Scans your codebase: framework, whether pages render on the server or only in the browser, public routes, head tags, robots/sitemap/llms.txt, JSON-LD, hreflang, onClick navigation, images without alt or size. | none (local) |
| `katman_audit_site` | Audit Week or Pro | Audits the live site as crawlers see it: robots.txt, sitemap, redirects, HSTS, compression, soft 404s, AI bot access through your CDN, and per page status, title, canonical, headings, text without JavaScript, JSON-LD, og tags, hreflang and internal links. | your site |
| `katman_indexnow` | Pro only | Sets up IndexNow, submits only new or changed URLs, and gives the manual checklist for Google Search Console, Bing Webmaster Tools and Brave. Dry run by default. | your site, api.indexnow.org |
| `katman_keywords` | Audit Week or Pro | Expands a seed keyword with Google autocomplete (at most 40 requests per call), clusters the results and suggests situation and single-question pages. | suggestqueries.google.com |
| Visibility |
| `katman_visibility_run` | Audit Week or Pro | Asks your question set to the models behind ChatGPT, Claude, Gemini, Perplexity and Grok with live web search: who is named, recommended first and cited. Shows the calls and the cost estimate first; capped at $3 by default. | openrouter.ai (your key) |
| `katman_manual_check` | Audit Week or Pro | Gives you the questions to ask in the ChatGPT, Claude or Perplexity app while logged out, then parses the answer you paste. Works without an OpenRouter key and within the apps’ terms. | none (local) |
| `katman_setup_monitoring` | Pro only | Writes a GitHub Actions workflow that re-runs the check and the audit every week with your own key and commits the .katman/ changes. | none (local) |
| `katman_sync` | Pro only | Sends a project summary to your katman.pro dashboard: gate pass counts, visibility rates, plan progress, issue titles and dates. A dry run shows the exact payload first; code, file contents, answers and prompts are never sent. | katman.pro, only with dry\_run: false |

## Install

Katman MCP runs locally over stdio: your AI coding tool starts it with npx -y katman-mcp. Pick your tool. The OpenRouter key is optional until you run a visibility check.

Every tool except katman\_account needs your KATMAN\_KEY. It comes with Audit Week or Katman Pro: buy one, create the key in your account (katman.pro/app → MCP) and put it where the snippets below show km\_live\_... or KATMAN\_KEY.

### Cursor

Click the button to open Cursor’s install dialog, then paste your key into KATMAN\_KEY. Or paste the JSON, with your key in place of km\_live\_..., into ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (this project). The OpenRouter key is only needed for visibility runs; leave it empty to start.

[Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=katman&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImthdG1hbi1tY3AiXSwiZW52Ijp7IktBVE1BTl9LRVkiOiIiLCJPUEVOUk9VVEVSX0FQSV9LRVkiOiIifX0=)

mcp.json ~/.cursor/mcp.json

```
{
  "mcpServers": {
    "katman": {
      "command": "npx",
      "args": [
        "-y",
        "katman-mcp"
      ],
      "env": {
        "KATMAN_KEY": "km_live_...",
        "OPENROUTER_API_KEY": "sk-or-..."
      }
    }
  }
}
```

### Claude Code

Run one command in your project folder, with your key in place of km\_live\_..., and use the second command if you don’t want visibility runs yet.

Terminal

```
claude mcp add katman -e KATMAN_KEY=km_live_... -e OPENROUTER_API_KEY=sk-or-... -- npx -y katman-mcp
```

Terminal without an OpenRouter key

```
claude mcp add katman -e KATMAN_KEY=km_live_... -- npx -y katman-mcp
```

### VS Code

Click the button to install for Copilot agent mode and add your key to KATMAN\_KEY in your user settings, or add the server to .vscode/mcp.json. With the JSON below, VS Code asks for your keys once and keeps them out of the file.

[Install in VS Code](vscode:mcp/install?%7B%22name%22%3A%22katman%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22katman-mcp%22%5D%2C%22env%22%3A%7B%22KATMAN_KEY%22%3A%22%22%7D%7D)

mcp.json .vscode/mcp.json

```
{
  "inputs": [
    {
      "type": "promptString",
      "id": "katman-key",
      "description": "Katman key from katman.pro/app (required)",
      "password": true
    },
    {
      "type": "promptString",
      "id": "openrouter-key",
      "description": "OpenRouter API key (optional, only for visibility runs)",
      "password": true
    }
  ],
  "servers": {
    "katman": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "katman-mcp"
      ],
      "env": {
        "KATMAN_KEY": "${input:katman-key}",
        "OPENROUTER_API_KEY": "${input:openrouter-key}"
      }
    }
  }
}
```

### Claude Desktop

Settings → Developer → Edit Config opens claude\_desktop\_config.json. Add your key, and because Claude Desktop has no project folder, tell Katman where your code lives with KATMAN\_PROJECT\_ROOT. Then restart the app.

claude\_desktop\_config.json macOS: ~/Library/Application Support/Claude/ · Windows: %APPDATA%\\Claude\\

```
{
  "mcpServers": {
    "katman": {
      "command": "npx",
      "args": [
        "-y",
        "katman-mcp"
      ],
      "env": {
        "KATMAN_KEY": "km_live_...",
        "OPENROUTER_API_KEY": "sk-or-...",
        "KATMAN_PROJECT_ROOT": "/absolute/path/to/your/project"
      }
    }
  }
}
```

### Windsurf

Add the server to Windsurf’s MCP config with your key in place of km\_live\_..., then refresh the MCP list in Cascade.

mcp\_config.json ~/.codeium/windsurf/mcp\_config.json

```
{
  "mcpServers": {
    "katman": {
      "command": "npx",
      "args": [
        "-y",
        "katman-mcp"
      ],
      "env": {
        "KATMAN_KEY": "km_live_...",
        "OPENROUTER_API_KEY": "sk-or-..."
      }
    }
  }
}
```

### Codex CLI

Add a table to Codex’s config. env\_vars passes KATMAN\_KEY and OPENROUTER\_API\_KEY from your shell, so neither key sits in the file. Export KATMAN\_KEY before you start Codex; OPENROUTER\_API\_KEY is optional.

config.toml ~/.codex/config.toml

```
[mcp_servers.katman]
command = "npx"
args = ["-y", "katman-mcp"]
env_vars = ["KATMAN_KEY", "OPENROUTER_API_KEY"]
```

### Gemini CLI

Add the server to Gemini CLI’s settings. $KATMAN\_KEY and $OPENROUTER\_API\_KEY are read from your environment; KATMAN\_KEY is required, the OpenRouter key only for visibility runs.

settings.json ~/.gemini/settings.json

```
{
  "mcpServers": {
    "katman": {
      "command": "npx",
      "args": [
        "-y",
        "katman-mcp"
      ],
      "env": {
        "KATMAN_KEY": "$KATMAN_KEY",
        "OPENROUTER_API_KEY": "$OPENROUTER_API_KEY"
      }
    }
  }
}
```

Then ask your agent, in plain words: “Use Katman to check https://your-site.com.” It calls katman\_start first and tells you the next step.

[Don’t have a key yet? Start with Audit Week ($3 once, 7 days)](https://katman.pro/app/login?next=%2Fapp%2Fbilling%3Fbuy%3Daudit_week)

## The same checks from a terminal

Every check also runs as a command, without an AI agent, so you can put it in CI or run it before a deploy. The commands follow the same plans as the tools: account needs no key; scan, audit, keywords, plan, check and report need Audit Week or Pro; indexnow needs Pro.

CLI

```
npx -y katman-mcp                      # MCP server (stdio)
npx -y katman-mcp account              # your plan (no key needed)
npx -y katman-mcp scan [path]          # codebase scan
npx -y katman-mcp audit <url> [--max 50] [--root .]
npx -y katman-mcp keywords "<seed>" [--lang en]
npx -y katman-mcp plan [--root .]      # page plan and tasks
npx -y katman-mcp check [--root .] [--yes] [--max-cost 3] [--models a,b]
npx -y katman-mcp report [--root .]
npx -y katman-mcp indexnow [--root .] [--submit]   # Pro only
```

## What Katman can do on your machine

Katman is a local program with access to your project, so here is exactly what it touches.

Reads

Files under your project root. It skips node\_modules, .git and build output, and never reads .env\*, .dev.vars\*, \*.pem, \*.key, \*.p12 or files with “secret” or “credential” in the name.

Writes

Only the .katman/ folder, which is safe to commit and never holds secrets. The exceptions are katman\_generate and katman\_setup\_monitoring when you pass write: true, and they never overwrite a file unless you pass overwrite: true.

Network

Only when a tool is called: your own site; openrouter.ai for visibility runs (with your key, after a cost estimate); api.indexnow.org (katman\_indexnow with dry\_run: false); suggestqueries.google.com (katman\_keywords, at most 40 requests); katman.pro for the licence check and katman\_sync (next item).

What goes to katman.pro

Without KATMAN\_KEY, Katman never contacts katman.pro. With it, the MCP checks your plan at most once a day (it sends the key and the MCP version) and keeps working offline for 7 days after the last check; katman\_sync sends a project summary (gate counts, visibility rates, plan progress, issue titles, dates) only when you call it. Code, file contents, AI answers and your OpenRouter key never leave your machine. No usage tracking.

Your key

The OpenRouter key is read from OPENROUTER\_API\_KEY (or KATMAN\_OPENROUTER\_API\_KEY). It is never written to disk and never printed.

No chat-app automation

Katman never drives the ChatGPT, Claude or Perplexity apps with a headless browser. App answers are recorded with katman\_manual\_check, where you paste them.

## What it costs

Audit Week costs $3, paid once, for 7 days, and doesn’t renew. Katman Pro costs $29 a month or $290 a year at the founding price for the first 100 customers. The only other money that moves is your own OpenRouter credit, paid by you to OpenRouter when you run a visibility check.

-   ### [Audit Week](https://katman.pro/pricing)

    $3 once, for 7 days

    The audit and recommendation tools for 7 days: code scan, live-site audit, research, keywords, the page plan, content check, AI-visibility runs and the report. It finds what’s wrong and tells you what to do; it doesn’t build pages or write files in your site. One per account, and it doesn’t renew.

-   ### [Katman Pro](https://katman.pro/pricing)

    $29/month or $290/year

    Everything in Audit Week, plus the tools that do the work: prompts P0–P14 with acceptance checks, page briefs, file generation (robots.txt, llms.txt, JSON-LD), IndexNow, monitoring and dashboard sync. Plus the full course and an invite to the private community. Founding price for the first 100 customers, kept for as long as your subscription stays active. After that, Pro is $49/month.

-   ### [The book and the workbook (PDF)](https://katman.pro/guide)

    $14 each, $20 together

    Sold on their own, not part of Audit Week or Pro: the Katman book and the 30-day GEO workbook, each in English and Turkish. One-time payment, yours to keep.


Visibility runs use your own OpenRouter key: about $2.4 per run on the default panel (range $1.2–3.7), paid by you to OpenRouter, shown before anything runs and capped at $3 by default. This cost is separate from Audit Week and Pro. No ranking guarantees.

| Item | Who pays | Amount |
| --- | --- | --- |
| Audit Week: the audit and recommendation tools (code scan, live-site audit, research, keywords, plan, content check, visibility runs, manual checks, report) | you, once: one per account, no renewal | $3 for 7 days |
| Katman Pro: everything in Audit Week plus prompts, page briefs, file generation, IndexNow, monitoring and sync; the course and the community | you, monthly or yearly; cancel any time | $29/month or $290/year (founding price for the first 100 customers; then $49/month) |
| The agent’s reasoning (Cursor, Claude Code…) | your existing subscription | Nothing extra from Katman |
| Visibility run: 14 questions × 5 assistants | your OpenRouter credit | About $2.4 on the default panel ($1.2–3.7); the exact estimate is shown first and runs stop at $3 by default |
| Manual checks in the ChatGPT, Claude or Perplexity apps (katman\_manual\_check) | included in Audit Week and Pro | Nothing extra; no OpenRouter key needed |

### Visibility-run panels

| Panel | What it asks | Typical cost per run |
| --- | --- | --- |
| `economy` (default) | The same 5 assistants on their smaller models, with native search | ≈ $2.4 (range $1.2–$3.7) |
| `full` | Flagship models | ≈ $4.6 (range $2.2–$6.9) |
| `probe` | ChatGPT and Perplexity only | ≈ $1.8 (range $0.7–$2.8) |

Measured against live OpenRouter pricing on 30 September 2026; search results are billed as input tokens. The exact estimate is shown before anything runs, and runs stop at $3 by default. API answers are a proxy for the consumer apps: studies in 2026 found 15–32% overlap in the brands they name, so katman\_manual\_check records the apps’ own answers when you paste them in.

[Full pricing: Audit Week and Pro compared](https://katman.pro/pricing)

## An example session

This is roughly what a first session looks like in Claude Code or Cursor. Every tool in it works with Audit Week.

Example

```
you     Use Katman to check https://your-site.com
agent   → katman_start { "site_url": "https://your-site.com" }
katman  Step 1 of 4, Research: not started.
        Next: katman_research { "mode": "template" }
agent   → katman_scan_code {}
katman  Vite + React, rendered in the browser. The home page
        sends 31 words without JavaScript. Gate "read": fail.
        Suggested task: P2 (put the text in the HTML).
agent   → katman_audit_site { "url": "https://your-site.com" }
katman  GPTBot 403 and ClaudeBot 403 at the CDN; OAI-SearchBot 200.
        /does-not-exist answers 200: soft 404 (P11).
agent   → katman_plan {}
katman  plan.md: 12 tasks in the book's order. First P2, P11, P4.
        Each task lists its acceptance criterion.
```

Example

An illustration, shortened and made up. Your output will differ.

## Get an email when a new version ships

[Read the documentation](https://katman.pro/docs)

## Frequently asked questions

### What is an MCP server?

MCP (Model Context Protocol) is the standard way for AI coding tools to call outside tools. Katman MCP is a local server your tool starts with npx -y katman-mcp; the agent then calls Katman’s tools the same way it reads files or runs commands.

### Do I need an OpenRouter key?

Only for visibility runs (katman\_visibility\_run), which ask the models with live web search. Every other tool works without an OpenRouter key. A run first shows the calls and the estimated cost, and it stops at $3 unless you raise the limit. The cost is paid by you to OpenRouter, separately from Audit Week and Pro.

### Does Katman change my code?

Katman itself writes only to the .katman/ folder in your project; your AI coding agent makes the code changes, using Katman’s prompts and acceptance criteria. Two tools can write a file when you ask them to (katman\_generate and katman\_setup\_monitoring with write: true), and neither overwrites an existing file unless you pass overwrite: true.

### Why doesn’t Katman automate the ChatGPT app?

The terms of ChatGPT, Claude and Perplexity forbid extracting answers from their apps with a script, accounts get banned, and it breaks every week. Katman uses the providers’ own web-search models through OpenRouter instead, and katman\_manual\_check records an answer from the app when you paste it in.

### Which models does a visibility run use?

Five assistants: ChatGPT, Claude, Gemini, Perplexity and Grok, all with live web search. The default economy panel uses their smaller models (about $2.4 per run), the full panel uses flagship models (about $4.6) and the probe panel asks only ChatGPT and Perplexity (about $1.8). API answers are a proxy for the consumer apps: studies in 2026 found 15–32% overlap in the brands they name, so katman\_manual\_check lets you record the apps’ own answers too.

### Does it work with Lovable, Bolt or v0?

Katman runs next to your code. Sync or export the project to GitHub, open it in Cursor, Claude Code or VS Code and add Katman there. The live-site audit (npx -y katman-mcp audit [https://your-site.com](https://your-site.com)) works on any public URL, including sites hosted on those platforms.

### Is Katman MCP free?

No. Audit Week ($3 once, for 7 days) unlocks the 10 audit and recommendation tools: katman\_start, katman\_research, katman\_scan\_code, katman\_audit\_site, katman\_keywords, katman\_plan, katman\_lint\_content, katman\_visibility\_run, katman\_manual\_check and katman\_report. Katman Pro ($29 a month at the founding price, or $290 a year) adds the tools that write pages and files: katman\_prompt, katman\_page\_brief, katman\_generate, katman\_indexnow, katman\_setup\_monitoring and katman\_sync. Every tool except katman\_account needs KATMAN\_KEY.

### What is KATMAN\_KEY?

Your Katman licence key. It comes with Audit Week or Katman Pro: create it in your account (katman.pro/app, MCP page) and add it to your MCP config’s env block, next to the OpenRouter key. Every tool except katman\_account needs it. Katman checks the key with katman.pro at most once a day and keeps working offline for up to 7 days after the last check; Audit Week still ends on its end date.

## Related pages

-   [**Docs** Install Katman MCP in Cursor, Claude Code, VS Code and other AI coding tools, learn what each of the 17 tools does and run research, plan, build and verify.](https://katman.pro/docs)
-   [**Pricing** Audit Week costs $3 once for 7 days of Katman's audit and recommendation tools. Katman Pro adds the build tools, the course and the community: $29/month.](https://katman.pro/pricing)
-   [**AI crawler checker** Free: we load your homepage as GPTBot, OAI-SearchBot, ClaudeBot, PerplexityBot and 8 other bots, then show which ones your CDN blocks and what robots.txt says.](https://katman.pro/tools/ai-crawler-checker)
-   [**The Katman method: research, plan, build, verify** Four steps, three gates and 15 prompts with acceptance criteria that make a site readable, quotable and recommendable by ChatGPT, Claude, Gemini and Perplexity.](https://katman.pro/method)

Updated 30 September 2026 · Katman
