Anyone working on a website usually has their analysis tool in a different window from the work itself. You read in a dashboard that a page has no H1, switch to the editor, change it, switch back, tick it off. None of those switches costs much on its own, but together they are the reason half of all detected problems never get touched.
MCP changes something fundamental here: the assistant you're already working with gets access to your analysis data, and it can not only read it but write back to it. This article explains what's behind that, how to connect Traffalyzer, and where the limits are.
What MCP is
The Model Context Protocol is an open standard that lets a language model talk to outside systems. Think of it as a power strip: a client like Claude Code, Claude Desktop or Cursor brings the plug, a service like Traffalyzer provides the socket. Neither needs to know the other; they only need to speak the same format.
The difference from a chatbot that can browse the web matters. A model with web search finds public pages. A model with MCP access gets your data: the queries from your Search Console, the findings from your latest crawl, your growth plan. And it can do things, not just report on them.
Why this changes SEO work
The value isn't that you now see numbers in a chat instead of a dashboard. It's that diagnosis and implementation collapse into a single step.
A practical example. You're in your editor working on your site and ask: "What should I improve on this page next?" The assistant pulls the open findings, sees that five images have no alt text, adds them right there in the code — and then ticks the measure off in the analysis tool. Your effect tracking keeps running without you ever opening the dashboard.
That's the real change: the gap between "I know what to do" and "I did it" disappears. And with it the most common reason SEO lists get worked through — namely, not at all.
Connecting Traffalyzer
Access runs through your normal login. There's no API key to copy and store somewhere, and no token that quietly expires on you.
In Claude Code:
claude mcp add --transport http traffalyzer https://traffalyzer.com/api/mcp
Then type /mcp in a session, pick traffalyzer and confirm "Authenticate". A browser window opens with the consent page, you confirm with your usual login, done.
In claude.ai or Claude Desktop: Settings → Connectors → "Add custom connector" and paste the same address.
In Cursor: add the server to ~/.cursor/mcp.json (global) or .cursor/mcp.json (per project):
{
"mcpServers": {
"traffalyzer": {
"url": "https://traffalyzer.com/api/mcp"
}
}
}
Cursor handles both Streamable HTTP and OAuth, so signing in works the same way as in Claude Code, through a browser window.
In VS Code with GitHub Copilot: create .vscode/mcp.json in your project — or use the command palette entry "MCP: Open User Configuration" to apply it everywhere. The type field matters here:
{
"servers": {
"traffalyzer": {
"type": "http",
"url": "https://traffalyzer.com/api/mcp"
}
}
}
In ChatGPT: possible, with one caveat. Turn on developer mode in settings, then the server can be added as a connector. For "Deep Research" and "Company Knowledge", however, OpenAI requires a server to expose exactly two tools named search and fetch — a deliberately narrow, read-only schema. Traffalyzer instead offers twelve domain-specific tools that can also write. In those two ChatGPT modes the connection therefore won't work; in developer mode it will.
The address is also in your settings under "AI assistants (MCP)", with a copy button.
One note for honesty's sake: we tested this with Claude Code and with a purpose-built test client that speaks the protocol directly. The details for Cursor, VS Code and ChatGPT come from their respective documentation. This field moves fast, so any of them may look different sooner than this article does.
What the assistant can do
Twelve tools are available. They fall into three groups.
Overview and prioritisation. next_actions is the entry point for anything starting with "what should I do". In a single call it answers where to begin across all your projects: critical findings, open tasks, the next unfinished step of your growth plan, projects with a stale scan. Without it, an assistant would have to query every project separately and compare the results itself. list_domains returns the project list with scores.
Reading data. search_console_queries and search_console_pages fetch real queries, positions and clicks. traffic_trend shows the trajectory over weeks, page_report the full picture for a single page. growth_plan returns diagnosis, bottleneck and steps; quests_and_issues the task list with affected URLs. run_scan starts a new analysis, get_scan_status follows it.
Writing back. complete_quest and complete_plan_step mark a measure as done, award the points and kick off effect verification. These two are what turn an information system into a working system.
Four sentences that work right away
Go through my Traffalyzer projects and tell me what's most urgent.
Which queries get impressions but barely any clicks?
Show me step one of my growth plan and explain the reasoning behind it.
I've added the missing alt texts — tick the task off.
The last one is the interesting one. It closes a loop that otherwise stays open.
What doesn't happen
For a connection that gives outside software access to your own data, the limits belong in the description as much as the possibilities do.
An assistant sees only your own projects. Every access to a project goes through an ownership check. A foreign or invented project id always returns the same answer — never data, and no hint as to whether it exists at all. That distinction matters: otherwise the error message itself would reveal which ids are real.
The sign-in is yours. Access hangs on your login, not on a key that can be passed around. Withdraw consent and access is closed.
There's a daily limit. 200 calls on a free account, 2,000 on a paid one. That's ample for normal work, but it stops a badly built automation from running in circles for hours.
Writing tools ask first. The descriptions of both ticking-off tools carry an explicit instruction never to call them unprompted. An assistant shouldn't quietly empty your task list.
And ticking off replaces no work. Marking a measure as done without having done it corrupts your own effect tracking. Traffalyzer then checks whether anything measurably changed — tick things off prematurely and all you get is worse data about yourself.
Who this is for
The people who gain most are those who edit their website themselves and already work with an AI assistant. For them the window switching disappears, and the hit rate on actually implementing things rises noticeably.
If an agency runs your site and you only read the reports, you don't need this. The dashboard stays the right place for you. And if you have no analysis running at all, start there: an assistant can only pass on what has been measured.