// MCP Server

Plug sourced comparison facts
into the AI that builds your site.

RivalCheck's remote MCP server gives Claude Code, Cursor, VS Code and any header-capable MCP client the facts, corrections and drafts behind your comparison pages — every rival claim quoted from the rival's own website, with the source URL and the date it was checked.

Get your API key Jump to setup

Who can use it: every paid plan, and RivalCheck monitoring customers while subscribed. One API key works for both MCP and the REST API.

Overview

Your comparison pages, built where you already work

RivalCheck fact-checks your published comparison, “vs” and alternatives pages against each rival's own site, proposes corrected copy, and drafts the comparison pages you're missing. The MCP server hands all of that to your coding agent, so it can build or fix the page in your real codebase — Next.js, Astro, Rails, a Webflow export, whatever you use — instead of you copying facts out of a dashboard.

MCP (Model Context Protocol) is an open standard that lets an AI assistant call tools on a remote server. You add RivalCheck once; after that you just ask, and the assistant decides which RivalCheck tool to call.

Getting Started

Connect

Create an API key in Settings. Keys start with rc_live_. Then point your client at the server:

https://rivalcheck.com/mcp

It's a remote server over Streamable HTTP. There's nothing to install and nothing to run locally — you send your key as an Authorization: Bearer header.

Claude Code

Run this in your project directory:

claude mcp add --transport http rivalcheck https://rivalcheck.com/mcp --header "Authorization: Bearer YOUR_API_KEY"

Check it with claude mcp list or /mcp inside a session.

Cursor

Add to .cursor/mcp.json in your project (or ~/.cursor/mcp.json for every project):

{
  "mcpServers": {
    "rivalcheck": {
      "url": "https://rivalcheck.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

VS Code

Add to .vscode/mcp.json:

{
  "servers": {
    "rivalcheck": {
      "type": "http",
      "url": "https://rivalcheck.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

{}

Any other client, or raw HTTP

Any MCP client that can talk Streamable HTTP and send a custom header will work. To see the wire format, here's a single tool call with curl:

curl -X POST https://rivalcheck.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2026-07-28" \
  -H "Mcp-Method: tools/call" \
  -H "Mcp-Name: get_facts" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_facts","arguments":{"company":"typeform"},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"curl","version":"1"},"io.modelcontextprotocol/clientCapabilities":{}}}}'

Not supported yet: OAuth custom connectors

RivalCheck authenticates with an API key header only; OAuth isn't supported yet. Clients that can only add remote servers through an OAuth “custom connector” flow — the claude.ai web app and Claude Desktop's custom connector screen — can't connect directly today. Use Claude Code, Cursor, VS Code, or any client that lets you set a request header.

Reference

Tools

You don't call these yourself — your assistant picks them. Each one maps to a REST endpoint that returns the same data.

Tool	What it does	Arguments
`get_facts`	Every sourced fact about your company and its rivals: company, dimension (e.g. “Starting price”), value, status (`verified` / `self_asserted` / `corroborated`), `source_url` and `checked_at`. Rival values are quoted from the rival's own website.	`company` — optional; a rival name, domain or id to narrow the results
`list_pages`	Your comparison pages: published pages RivalCheck fact-checks (with a findings summary) and drafts RivalCheck wrote.	`kind` — optional; `published` or `draft`
`get_page`	One page in full: findings (verdict `contradicted` / `agrees` / `minor_difference` / `unchecked`, your claim, what the rival's page says, source URL, when the source was verified), proposed edits, and for drafts the Markdown with frontmatter.	`page_id` — required
`audit_page`	Enrol a published page for fact-checking and weekly re-checks. Runs in the background — poll `get_page` for results.	`url` — required
`list_edits`	Proposed corrections: `original_text` → `suggested_text`, with the source that justifies the change.	`status` — `proposed` (default), `accepted`, `rejected`, `stale` or `all`; `page_id` — optional
`decide_edit`	Record that a correction was accepted or rejected. The decision is written to the audit log.	`edit_id`, `decision` (`accepted` / `rejected`) — both required
`list_gaps`	Rivals you don't have a comparison page for yet, with how many sourced facts RivalCheck holds for each and whether there's enough to draft one (`ready_to_draft`).	None
`draft_page`	Draft “<Your company> vs <Rival>” as Markdown. The comparison table is quoted from sources, never generated, with footnotes; the prose is fair to the rival. Runs in the background — poll `get_page`.	`competitor` — required; `brief` — optional tone notes (never used as a source of facts); `replace` — boolean
`get_audit_log`	The hash-chained audit trail, newest first, with `chain_intact` telling you whether the chain verifies.	`limit` — 1–200, default 50; `before_id` — optional, for paging

Example: a `get_facts` result (excerpt)

{
  "facts": [
    {
      "company": "Typeform",
      "company_role": "competitor",
      "dimension": "Starting price",
      "value": "$29/mo",
      "status": "verified",
      "source_url": "https://www.typeform.com/pricing/",
      "checked_at": "2026-09-29T06:12:40Z"
    }
  ]
}

Reference

Prompts

The server also ships two MCP prompts — ready-made instructions your client can offer as slash commands or templates.

PROMPT build_comparison_page

Has the assistant pull the facts for a rival, use RivalCheck's draft (or create one), build the page in your project's own stack with footnoted sources, then call audit_page on the live URL once it ships so it stays fact-checked.

Arguments: competitor (required), stack (optional, e.g. “Next.js app router + MDX”, “Astro”, “Webflow CMS”)

PROMPT apply_corrections

Has the assistant find each proposed correction's original_text in your project's content, replace it with the suggested_text, show you the changes, then record each decision with decide_edit.

Arguments: none

In Practice

Example workflows

Build a new vs page in your codebase

In Claude Code, from your site's repo:

“Use rivalcheck to build our /vs/typeform page in this Next.js app.”

The assistant calls get_facts for Typeform, fetches or requests a draft with draft_page, polls get_page for the Markdown, then writes the route and components in your existing conventions — with every rival value footnoted to its source URL.

Fix what's wrong on your live pages

“Apply RivalCheck's corrections to our comparison pages.”

The assistant calls list_edits, finds each original_text in your content files, swaps in the suggested_text, shows you the diff, and records each accept or reject with decide_edit.

Find the pages you're missing

“Which rivals don't we have a comparison page for yet, and which are ready to draft?”

The assistant calls list_gaps and reports each rival's sourced-fact count and ready_to_draft flag.

Keep a page you just shipped honest

“We just deployed /vs/jotform — have RivalCheck check it.”

The assistant calls audit_page with the live URL. RivalCheck fact-checks it now and re-checks it weekly; results show up in get_page and new corrections in list_edits.

Details

Protocol notes

Transport: Streamable HTTP at https://rivalcheck.com/mcp. Stateless — there are no sessions and no session IDs. Responses are plain JSON.
Current spec: implements MCP revision 2026-07-28 — the protocol version travels in each request's _meta, the MCP-Protocol-Version, Mcp-Method and Mcp-Name headers mirror the request body, and server/discover is supported.
Older clients: clients that open with an initialize handshake on 2025-11-25, 2025-06-18 or 2025-03-26 also work, so today's Claude Code, Cursor and VS Code releases connect as-is.
Capabilities: tools and prompts. Not implemented: resources, subscriptions, server-sent event streams, and OAuth.
Auth: Authorization: Bearer rc_live_… on every request — the same key as the REST API.

Details

Limits and errors

Rate limit: 1,000 requests per day per organisation, shared between MCP and the REST API. It resets at midnight UTC.

Tool errors come back as a normal tool result with isError: true and a code your assistant can act on:

not_found	No page, edit or tracked competitor matches what was asked for.
missing_argument	A required argument (e.g. `page_id`, `url`, `competitor`) wasn't supplied.
already_decided	The edit has already been accepted, rejected or marked stale.
limit_reached	You already have the maximum number of fact-checked pages or drafts.

A missing or invalid key, lapsed access, or an exhausted daily limit is rejected at the HTTP level before any tool runs. If your client shows a connection error, check the key in Settings first.

Common Questions

FAQ

Where do the facts come from?

Rival values are quoted from the rival's own website, and each fact carries its source_url and checked_at time. Your own company's values are marked self_asserted until your site corroborates them. Drafted comparison tables are built only from these sourced facts — a brief can shape tone but is never treated as a source.

Do I need a paid plan?

You need either a paid plan or a RivalCheck monitoring subscription. Monitoring customers get API and MCP access while subscribed; if you cancel, access runs to the end of the month you've paid for.

Can I use it from claude.ai or Claude Desktop?

Not directly yet. Their custom connector screens require OAuth, which RivalCheck doesn't support yet. Claude Code, Cursor and VS Code work today because they let you send the API key as a header.

I used the old `npx` package. What changed?

The local stdio wrapper has been retired. Remove it from your client config and add the remote server using the snippets above — your existing API key still works.

Can I use MCP and the REST API together?

Yes. They share the same key, the same data and the same daily limit. Use MCP from your editor and the REST API from scripts, CI jobs or your CMS build.

Give your coding agent the facts, with sources.

Create an API key, add one line to your client, and ask it to build or fix a comparison page.

Get your pages fixed REST API reference

Plug sourced comparison facts into the AI that builds your site.