# MCP for SEO: Connect Claude, ChatGPT or Cursor to Your Site

> MCP (Model Context Protocol) is the open standard that connects an AI assistant to external tools. For SEO, a single URL is enough: Tonaily's free server (https://app.tonaily.com/mcp/tools) audits any public website with no account, and Kira MCP connects your Tonaily account (Growth and Pro plans) with an API token, read-only if you prefer.

Source: https://tonaily.com/guides/mcp-seo/
Last updated: 2026-10-08
Checked against sources on: 2026-10-08

## What is MCP, and what does it change for your SEO?

MCP (Model Context Protocol) is an open standard that lets an AI assistant like Claude or ChatGPT call external tools. For SEO, it means your assistant can run an audit, read your keywords or check your robots.txt on its own, instead of you pasting screenshots into the chat.

Here is the typical scenario. You open Claude and ask "why doesn't my site show up in ChatGPT?". It answers with a list of generic tips, because it can't see your site. Connect an audit MCP server and ask the same question: it calls the tool, reads the robots.txt, spots that `OAI-SearchBot` is blocked and gives you the line to fix.

```quote source="Model Context Protocol, What is MCP?" href="https://modelcontextprotocol.io/docs/getting-started/intro"
Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems.
```

You only need three terms. The **host** is the application (Claude Desktop, Claude Code, Cursor, ChatGPT). The **server** is the program that exposes tools. The **tools** are the functions the model can call. The [architecture documentation](https://modelcontextprotocol.io/docs/learn/architecture) describes two transports: `stdio` for a server running on your machine, and Streamable HTTP for a remote server, which supports bearer tokens, API keys and custom headers. Both Tonaily servers are remote: nothing to install.

## Which MCP server should you connect for SEO: the free one or Kira MCP?

Start with the free server if you want to audit a website, yours or a competitor's; move to Kira MCP when you want the agent to work on your own data (keywords, sequences, AI visibility). They are two separate servers, with two URLs.

| | Free analysis server | Kira MCP (account server) |
|---|---|---|
| URL | `https://app.tonaily.com/mcp/tools` | `https://app.tonaily.com/mcp` |
| Account | None | Growth or Pro plan |
| Authentication | None | `tny_…` API token (Bearer) |
| What it sees | Any public website | Your organization, and only yours |
| Tools | 5 | 16, plus 1 prompt |
| Rate limit | 10 calls/min per IP | 120 calls/min per token |

The 5 free tools:

- `check-ai-crawlers`: checks 12 AI crawlers (6 citation, 6 training), whether an llms.txt and an llms-full.txt exist, and the schema.org markup on the homepage. Instant answer. With `includeFile`, it also returns the corrected robots.txt.
- `audit-website` then `get-audit-report`: scores the site out of 100 and recommends 5 post topics. The analysis takes 30 seconds to 2 minutes.
- `compare-sites`: puts two sites on the same 100-point grid, check by check.
- `generate-llms-txt`: writes the site's llms.txt, ready to drop at the root, plus the corrected robots.txt.

Kira MCP has 16 tools. Thirteen stay visible with a read-only token: brand profile, topics to write, keywords, competitor gap, AI visibility report, the text of assistant answers, internal linking, quotas…, plus `get-suggestion`, which tracks a plan in progress. The other 3 require a write token and are covered below in the security section. The full list is on the [MCP server page](/mcp/).

```tonaily
The free server runs the same analysis as the [free online audit](https://app.tonaily.com/tools/check/), opened up to agents: no account, no email. A domain already analyzed in the last 24 hours returns the existing report instead of running a new one.
```

## How do you add an MCP server in Claude Code?

One terminal command does it: `claude mcp add --transport http <name> <url>`, as documented by [Anthropic](https://code.claude.com/docs/en/mcp). For the free server:

```bash title="Terminal: free server"
claude mcp add --transport http tonaily-tools https://app.tonaily.com/mcp/tools
```

For Kira MCP, add the authentication header with `--header`:

```bash title="Terminal: Kira MCP"
claude mcp add --transport http tonaily https://app.tonaily.com/mcp \
  --header "Authorization: Bearer tny_your_token"
```

Three details matter:

1. **Scope.** By default (`--scope local`), the server is only available to you, in the current project, and the configuration is stored in `~/.claude.json`. `--scope user` makes it available across all your projects. `--scope project` writes it to `.mcp.json`, a file shared with your team: never put a token there.
2. **Checking.** `claude mcp list` lists your servers, and `/mcp` inside a session shows their status. Claude Code also flags hidden whitespace at the start or end of a value, such as the token in `headers.Authorization`: a common copy-paste mistake.
3. **The briefing prompt.** Kira MCP exposes one prompt, `tonaily-briefing`. Claude Code lists MCP prompts among its commands: type `/` and look for it, or run `/mcp__tonaily__tonaily-briefing`.

## How do you connect Claude Desktop or claude.ai?

With a **custom connector**: in Claude (desktop or browser), open **Customize > Connectors**, click **+ Add** then **Add custom connector**, give it a name and paste the server URL. That is the flow the [Claude Help Center](https://support.claude.com/en/articles/11175166) describes for individual plans as of October 8, 2026. On a Team or Enterprise plan, an Owner first adds the connector under **Organization settings > Connectors**, then each member clicks **Connect**. The [MCP site tutorial](https://modelcontextprotocol.io/docs/develop/connect-remote-servers) still goes through **Settings > Connectors**: menus move around, so look for either one.

- **Free server**: choose **No sign in** under Authentication.
- **Kira MCP**: under **Request headers**, add `Authorization` with the value `Bearer tny_your_token`. The Claude Help Center provides this field for servers that authenticate with "an API key, bearer token, or other fixed credential instead of OAuth".

Custom connectors are available on the Free, Pro, Max, Team and Enterprise plans, but **a Free account is limited to one custom connector**. Then, in a conversation, enable the connector from the **+** button at the bottom left, under **Connectors**.

## How do you connect Cursor?

With an `mcp.json` file: `.cursor/mcp.json` in the project, or `~/.cursor/mcp.json` for all your projects. A remote server is declared with `url` and, if needed, `headers` ([Cursor documentation](https://cursor.com/docs/context/mcp)).

```json title="~/.cursor/mcp.json"
{
  "mcpServers": {
    "tonaily-tools": {
      "url": "https://app.tonaily.com/mcp/tools"
    },
    "tonaily": {
      "url": "https://app.tonaily.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:TONAILY_TOKEN}"
      }
    }
  }
}
```

Cursor replaces `${env:TONAILY_TOKEN}` with the environment variable of the same name. That keeps the token out of the file, which matters if the file is committed to version control with the project. For a remote server, set the variable in your shell profile or your system.

## Can you connect ChatGPT to an MCP server?

Yes for the free server, no for Kira MCP, at least not in the ChatGPT app for now. OpenAI writes that ChatGPT cannot "present custom API keys" ([Authentication](https://developers.openai.com/plugins/build/auth)): it handles OAuth or anonymous access, while Kira MCP requires a fixed token.

To add the free server, OpenAI describes this path ([Connect and test your plugin](https://developers.openai.com/plugins/deploy/connect-chatgpt)): open the Plugins page in ChatGPT, click **+** then **Add custom MCP server**, enter a name, a description and the URL `https://app.tonaily.com/mcp/tools`, with no authentication. Read the warning, confirm with **I understand and want to continue**, then **Create as a plugin**. OpenAI notes that account and workspace rules apply to adding custom servers, and reminds you in its [MCP guide](https://developers.openai.com/api/docs/mcp/) that these servers are "not developed or verified by OpenAI".

On the OpenAI side, **Codex** accepts a token. Its `~/.codex/config.toml` configuration reads the token from an environment variable ([Codex documentation](https://learn.chatgpt.com/docs/extend/mcp?surface=cli)):

```toml title="~/.codex/config.toml"
[mcp_servers.tonaily]
url = "https://app.tonaily.com/mcp"
bearer_token_env_var = "TONAILY_TOKEN"
```

| Client | Free server | Kira MCP | Where do you set it up? |
|---|---|---|---|
| Claude Code | Yes | Yes | `claude mcp add` |
| Claude Desktop, claude.ai | Yes | Yes | Customize > Connectors |
| Cursor | Yes | Yes | `mcp.json` |
| ChatGPT | Yes | No | Plugins > Add custom MCP server |
| Codex | Yes | Yes | `~/.codex/config.toml` |

## What should you ask the agent once it's connected?

Ask for complete tasks, not tool calls: "audit this site and tell me what to fix" works better than "run audit-website". The analysis tools are asynchronous, so the agent has to wait and call again; the prompts below tell it to.

```mermaid
flowchart TD
  A["Your question"] --> B{"AI crawlers only?"}
  B -- Yes --> C["check-ai-crawlers"]
  C --> H["Instant answer"]
  B -- No --> D["audit-website"]
  D --> E["Tracking token"]
  E --> F["Wait 30 s to 2 min"]
  F --> G["get-audit-report"]
  G --> I["Score out of 100 and 5 topics"]
```

**Audit a website** (free server):

```prompt
Using the tonaily-tools MCP server, audit the website example.com.
1. Run check-ai-crawlers with includeFile set to true: tell me which citation crawlers are blocked (OAI-SearchBot, Claude-SearchBot, PerplexityBot…) and give me the corrected robots.txt.
2. Run audit-website, then call get-audit-report about every ten seconds until the report is ready.
3. Summarize the score out of 100, the three fixes with the best payoff, and the five recommended post topics.
Do not make up any search volume or Google ranking: the report contains none.
```

**Compare yourself to a competitor** (free server):

```prompt
Using tonaily-tools, compare example.com to competitor.com with compare-sites. As long as the status is not "completed", call the tool again with the same parameters after about ten seconds.
Then present in a table: each site's score, the checks each one wins, the editorial volume on both sides and the blocked AI crawlers. Finish with the three areas where I can close the gap fastest.
```

The comparison covers two technical diagnostics, not two complete SEO profiles: no traffic, no rankings. To understand why an assistant cites your competitor, the guide [why ChatGPT recommends your competitor](/guides/why-chatgpt-recommends-competitor/) goes further.

**Generate an llms.txt** (free server):

```prompt
Using tonaily-tools, generate the llms.txt for example.com with generate-llms-txt. If the analysis is not ready, call the tool again with the same parameters after about ten seconds.
Give me the file exactly as is, without rewording it, then list the pages it contains and flag any important pages on my site that are missing. Tell me where to put it.
```

llms.txt is a proposal ([llmstxt.org](https://llmstxt.org/)): a Markdown file at the root of a site that presents its content to language models. The tool lists up to twenty sampled pages: review the file before you publish it.

**Run your weekly SEO check-in** (Kira MCP):

```prompt
Using the tonaily MCP server, run my weekly SEO check-in.
Read, in this order: brand-profile, what-to-write, llm-visibility-report and quota-status.
Then tell me: which panel questions cite a competitor instead of me (read the answers with llm-answers to understand why), the topic to write first, and three internal links to add with internal-link-suggestions.
Do not create anything without my explicit approval.
```

To interpret the share of voice returned by `llm-visibility-report`, use the method in the guide [calculating your share of voice in AI](/guides/ai-share-of-voice/); to improve the quality of your question panel, see [the guide to choosing which questions to track](/guides/ai-visibility-prompts/).

## Is it risky to connect your account to an AI agent?

The risk comes down to two controls: trust in the server, and the token's permissions. A server that reads web content can expose the agent to prompt injection (hidden text in a page that gives the model orders), and Anthropic says so at the top of its documentation.

```quote source="Claude Code Docs, Connect Claude Code to tools via MCP" href="https://code.claude.com/docs/en/mcp"
Verify you trust each server before connecting it. Servers that fetch external content can expose you to prompt injection risk.
```

In other words: only connect servers whose publisher you know, and give each one the minimum permissions.

At Tonaily, Kira MCP tokens come in two levels. With **read** access, the agent reads the account and cannot change anything. With **read and write** access, three more tools appear: `plan-sequence` (propose an editorial plan), `create-sequence` (create the sequence, as a draft; the chosen keywords are then reserved) and `add-llm-prompt` (add a question to the panel; a question that names the brand or a competitor is rejected). With a read-only token, these three tools are removed from the list: the model doesn't see them and can't call them, even from memory.

No tool writes a post, publishes, or starts a billed measurement. Three actions stay in the interface, in front of a human: activating a sequence (that is what starts the writing), rerunning an AI visibility measurement and finding new competitors.

```checklist title="Connect an MCP server safely"
- Create a **read-only** token to start, in Settings > API (admins only)
- Copy the token right away: it starts with `tny_` and is shown only once
- Keep the token out of shared files: no team `.mcp.json`, use an environment variable instead
- One token per tool or per person, so you can revoke just one (ten active tokens max per organization)
- Check the list of exposed tools with `/mcp` (Claude Code) or in the connector settings
- Review every sequence proposal before approving it, then activate it yourself in Tonaily
- Revoke unused tokens
```

```tonaily
With [Kira MCP](/mcp/) (Growth and Pro plans), your assistant reads your brand's visibility on ChatGPT, Gemini and Grok, the text of the answers where a competitor is cited instead of you, and your topics to write. It proposes; you decide. Plans are detailed on the [pricing page](/pricing/).
```

## What should you do when the server doesn't respond as expected?

In most cases, the agent called too early, too often, or the token was pasted wrong. The checks, in order:

1. **The analysis keeps coming back as in progress.** That's normal for 30 seconds to 2 minutes. Ask the agent to space its calls about ten seconds apart.
2. **A rate-limit error, or a message saying the daily free analysis quota is reached.** The free server accepts 10 calls per minute per IP address, and caps analyses per day, both per IP address and across all visitors. A comparison counts as two analyses, one per domain that hasn't been analyzed in the last 24 hours. `check-ai-crawlers` doesn't start an analysis and stays available: try the rest again the next day.
3. **A report identical to yesterday's.** A domain analyzed in the last 24 hours returns the existing report: that's by design.
4. **Kira MCP refuses the connection.** Check the `Bearer ` prefix followed by a space, that there's no trailing space after the token, that the token hasn't been revoked, that the person who created it is still an admin of the organization, and that the organization is on the Growth or Pro plan.
5. **The agent doesn't offer to create a sequence.** The token is read-only; the `quota-status` tool confirms it.
6. **The site being analyzed is internal.** The free server only accepts public URLs.

If the audit reveals blocked crawlers, the guide [robots.txt and AI crawlers](/guides/ai-crawlers-robots-txt/) explains what to allow and what to block. Next, what actually helps you get cited by assistants is laid out in the [GEO guide](/guides/generative-engine-optimization/), and the tracking tools that compete with Tonaily are compared in [the AI visibility tools comparison](/guides/ai-visibility-tools/).

## FAQ

### Do you need to know how to code to use an MCP server?

No, not for a remote server. In Claude Desktop or ChatGPT, you paste a URL into a form. Claude Code and Cursor need a command or a small JSON file, which you copy as is.

### Does Tonaily's free MCP server require an account?

No. The https://app.tonaily.com/mcp/tools server is open to everyone, with no account and no token. It analyzes any public website with 5 tools, within a limit of 10 calls per minute per IP address.

### Can you connect Kira MCP to ChatGPT?

Not in the ChatGPT app for now: OpenAI says ChatGPT cannot present custom API keys, and Kira MCP authenticates with a fixed token. The free server, on the other hand, works with no authentication. On the OpenAI side, Codex accepts a token through its configuration.

### Can an agent connected through MCP publish a post on my website?

Not with Tonaily. No Tonaily MCP tool writes or publishes a post. With a write token, the most an agent can do is create a draft sequence and add a question to the AI visibility panel; writing only starts when a human activates the sequence in the interface.

### What is the difference between Kira in the app and Kira MCP?

Kira in the app is included in every plan and works inside the Tonaily interface. Kira MCP, from the Growth plan up, is a server that opens your account to your own assistant (Claude, Cursor, Codex) through an API token.


## Sources

- [What is the Model Context Protocol (MCP)? (Model Context Protocol)](https://modelcontextprotocol.io/docs/getting-started/intro)
- [Architecture overview (Model Context Protocol)](https://modelcontextprotocol.io/docs/learn/architecture)
- [Connect to remote MCP Servers (Model Context Protocol)](https://modelcontextprotocol.io/docs/develop/connect-remote-servers)
- [Connect Claude Code to tools via MCP (Claude Code Docs)](https://code.claude.com/docs/en/mcp)
- [Get started with custom connectors using remote MCP (Claude Help Center)](https://support.claude.com/en/articles/11175166)
- [Model Context Protocol (MCP) (Cursor Docs)](https://cursor.com/docs/context/mcp)
- [MCP (OpenAI)](https://developers.openai.com/api/docs/mcp/)
- [Connect and test your plugin in ChatGPT (OpenAI)](https://developers.openai.com/plugins/deploy/connect-chatgpt)
- [Authentication for plugins (OpenAI)](https://developers.openai.com/plugins/build/auth)
- [Model Context Protocol (OpenAI Codex)](https://learn.chatgpt.com/docs/extend/mcp?surface=cli)
- [The /llms.txt file (llmstxt.org)](https://llmstxt.org/)