Rivalize MCP Server
Rivalize MCP Server connects MCP clients to Rivalize’s cited competitor-intelligence API, mainly through read-only tools with optional opt-in writes.
Search Rivalize’s cross-customer company universe and read full company profiles by domain.
Generate one-call strategy teardowns covering positioning, pricing, ads, social, reviews, hiring, momentum, and weaknesses.
List your projects, reports, and tracked competitors; read reports whole or by section/competitor with paging.
Read latest competitor intelligence, cited sales battlecards (Pro), strategic timelines, competitive landscapes, data freshness, and source evidence.
Use Agent-plan tools to list tracked competitor slots and read raw collected data by group: core, ads_seo, extended.
Check whether a report run has finished with get_report_status.
With RIVALIZE_MCP_ALLOW_WRITES=1, add competitors, start/confirm reports, and set Agent-plan competitor slots.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Rivalize MCP Server give me a source-backed teardown of competitor stripe.com"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Rivalize MCP Server (@rivalize/mcp)
Give Claude, Cursor, Cline, or your own agent cited competitor intelligence as JSON, over the Model Context Protocol.
The Agent plan ($70 a year or $9 a month): API and MCP only, for your own AI. Rivalize collects; your own Claude, Cursor or agent does the thinking. No dashboard and no AI analysis, so it costs a few dollars.
3 competitors at once, refreshed every 7 days
Everything Rivalize collects about each, as JSON, with sources and collection dates
Reads Rivalize's database of companies already collected (
list_universe_companies,get_universe_company)500 API and MCP calls a day (up to 250 an hour)
Get the Agent plan at rivalize.ai/pricing. Developer and API documentation: rivalize.ai/developers.
What it does
This server connects Claude, Cursor or any other MCP client to Rivalize. Your assistant can tear down a competitor's positioning, pricing, ads, social presence, reviews, hiring and momentum in one call, search the Rivalize universe of tracked companies, and read the projects, reports, battlecards, timelines and evidence in your own Rivalize account. Every answer comes from data Rivalize has collected, with dates and sources, rather than from a model's memory.
The server is read-only by default. Three write tools, add_competitor,
run_report and set_agent_competitor, are available when you opt in with
RIVALIZE_MCP_ALLOW_WRITES=1. run_report starts a real report that uses your
credits, so it asks you to preview first and confirm.
Related MCP server: BizIntel MCP Server
Quick start
Requires Node.js 22 or newer (node --version).
Choose a plan at rivalize.ai/pricing: the Agent plan ($70 a year or $9 a month) is built for API and MCP use. A 14-day Growth trial is arranged with the Rivalize team; see the pricing page.
Create an API key under Settings → API Keys in the Rivalize app. Keys start with
rk_live_. A key from any plan works, including the free plan, which gets rate-limited reads.Add the server to your client using one of the blocks below.
Claude Desktop
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
or %APPDATA%\Claude\claude_desktop_config.json (Windows), then restart Claude
Desktop:
{
"mcpServers": {
"rivalize": {
"command": "npx",
"args": ["-y", "@rivalize/mcp"],
"env": { "RIVALIZE_API_KEY": "rk_live_..." }
}
}
}Claude Code
claude mcp add rivalize -e RIVALIZE_API_KEY=rk_live_... -- npx -y @rivalize/mcpCursor
Add to .cursor/mcp.json in your project, or ~/.cursor/mcp.json for all
projects:
{
"mcpServers": {
"rivalize": {
"command": "npx",
"args": ["-y", "@rivalize/mcp"],
"env": { "RIVALIZE_API_KEY": "rk_live_..." }
}
}
}Cline
In Cline, open the MCP Servers panel, choose Configure, then Configure MCP Servers. This opens cline_mcp_settings.json. Add:
{
"mcpServers": {
"rivalize": {
"command": "npx",
"args": ["-y", "@rivalize/mcp"],
"env": { "RIVALIZE_API_KEY": "rk_live_..." }
}
}
}Save the file. The rivalize server appears with a green dot after about 10 to 15 seconds (the first start downloads the package). On Windows, if it does not start, use "command": "cmd" and "args": ["/c", "npx", "-y", "@rivalize/mcp"].
If you ask Cline to install it for you, point it at llms-install.md.
Any MCP client (stdio)
The server speaks MCP over stdin and stdout. Configure your client to launch:
Setting | Value |
Command |
|
Arguments |
|
Environment |
|
Transport | stdio |
On Windows, some clients cannot launch npx directly because it is npx.cmd.
Use cmd as the command and /c npx -y @rivalize/mcp as the arguments
instead.
Plans and limits
Plan | Price | Competitors | What is included for MCP and API |
Agent | $70/yr or $9/mo | 3 at once, refreshed every 7 days | API and MCP only, for your own AI. Everything Rivalize collects about each competitor as JSON, access to Rivalize's database of companies already collected, and 500 API and MCP calls a day (250 an hour). One competitor change per slot per calendar month. No dashboard and no AI analysis. |
Starter | $19/mo ($190/yr) | 3 | Web dashboard, Monday briefing, cited change alerts, plus API, MCP and webhooks. |
Growth | $79/mo ($790/yr) | 10 | Everything in Starter with broader coverage, plus recommended actions on material changes. |
Pro | $199/mo ($1,990/yr) | 25 | Everything in Growth plus cited sales battlecards ( |
Agency | $599/mo ($5,990/yr) | 50 | Unlimited client workspaces, dashboard, battlecards, webhooks, plus API and MCP. |
Prices and limits are always current at rivalize.ai/pricing.
Tools
Sixteen read-only tools are always available: fourteen for dashboard plans and
two for Agent plans. The three write tools (add_competitor, run_report and
set_agent_competitor) are registered only when RIVALIZE_MCP_ALLOW_WRITES is
set to 1, true or yes; without it, they do not exist for the client.
Tool | Access | What it does | Key arguments |
| read | One-call strategy teardown of a competitor as Markdown: positioning, pricing, ads, social, reviews, hiring, momentum and weaknesses to attack, with when the data was last refreshed |
|
| read | Search the Rivalize universe, the cross-customer dataset of tracked companies |
|
| read | Full universe profile for one company: identity, pricing, features, ads, social, reviews, funding and hiring, rankings, signals, momentum |
|
| read | The projects in your account; returns the | none |
| read | Your reports, newest first. Reading never generates a report |
|
| read | One report as Markdown, whole or one section or one competitor at a time |
|
| read | The competitors you track, with momentum score, its threat-level band and, where the API provides it, each rival's standing on your Brief |
|
| read | Latest stored intelligence for one tracked competitor; a field is present only when it was measured |
|
| read | Cited sales battlecard for one tracked competitor. Requires a Pro plan |
|
| read | Evidence-linked timeline of competitor moves across pricing, product, people, funding and content/social |
|
| read | Current or stored weekly positions of competitors by activity and strategic importance |
|
| read | When each tracked competitor in a project was last actually observed, and how |
|
| read | The sources behind the facts for your product or one competitor: URL, what it supports, and when it was read |
|
| write, opt-in | Add competitor URLs to a project. Spends credits and queues analysis |
|
| write, opt-in | Starts a real report that uses your credits (paid dashboard plans; about 10 to 20 minutes). Two steps: without |
|
| read | Whether a report started with |
|
| read | Agent plans. The 3 tracked-competitor slots: who is tracked, when each was last collected, when it refreshes next (every 7 days), and how many slot changes are left this calendar month | none |
| read | Agent plans. The raw data collected about one tracked competitor, by group ( |
|
| write, opt-in | Agent plans. Put a competitor in a slot, or replace the one in a slot ( |
|
Agent plans cannot run work that needs a model (battlecards, teardown prose,
reports): the API refuses those calls with an agent_* code and the tool shows
you the API's sentence unchanged. run_report and the dashboard reads are for
dashboard plans; the Free and Agent plans are refused by the API with
PLAN_REQUIRED or agent_model_work_not_in_plan.
project_id and competitor_id are UUIDs from list_projects and
list_competitors. Tools that read your account only ever see your own data.
Report sections
get_report takes a section so your assistant can read the part a question
needs instead of the whole report:
Section | Contains |
| The report's headline sections ( |
| The cited sales battlecards |
| Every competitor's section in full |
| One topic gathered from every competitor's section |
A report has only the sections it has data for; asking for any other name
returns an error that lists the sections it does have. section combines with
competitor, so section: "pricing" with competitor: "Acme" returns Acme's
pricing. A figure the report's fabrication check could not match to a source is
kept and marked (not confirmed in the pages read); a name or citation the
check found to belong to another entity is taken out with its sentence, exactly
as in the report.
Long responses
Every response stays under 25,000 characters, and nothing is cut silently:
Markdown (
get_report,get_strategic_timeline,get_competitive_landscape) is split into pages at section boundaries. Each page starts withPage N of M, how much remains, and the exact call for the next page.Lists (
list_universe_companies,list_competitors,list_reports) returnpagination.next_offset; continue from it until it isnull.Objects (
get_universe_company, and timeline or landscape JSON) cap long arrays and record the cap in_capped. A field that still does not fit is listed in_omittedwith the call that fetches it.
Example prompts
"Tear down linear.app." (
teardown_competitor)"Who are the players in AI developer tools?" (
list_universe_companies)"Summarize my latest report, then show me what my competitors charge." (
list_reports,get_reportwithsection: "pricing")"Which of my competitors moved most this quarter, and what did they do?" (
get_competitive_landscape,get_strategic_timeline)"Give me sales talking points against my top competitor." (
list_competitors,get_battlecard)"Where does that pricing claim come from, and how fresh is it?" (
get_evidence,get_freshness)
Configuration
Variable | Required | Default | Description |
| yes | none | Your Rivalize API key. Must start with |
| no |
| Origin of the Rivalize API. A key only works on the server that issued it: leave this unset for rivalize.ai, and for a self-hosted or non-production Rivalize server set it to that server's origin, or every call returns 401. |
| no | off |
|
| no | none | Route requests through a corporate proxy. Lowercase forms are also read, and |
Troubleshooting
"Connection closed"
When the server cannot start, many clients show only "Connection closed" or a
failed status. The server prints the reason as the first line of its stderr,
prefixed rivalize-mcp:, and most clients keep stderr in their MCP log. The
usual causes:
RIVALIZE_API_KEYis missing or invalid. The log readsrivalize-mcp: RIVALIZE_API_KEY is required, or says the key does not look like a Rivalize API key (it must start withrk_live_). Put the key in the server'senvblock and restart the client.Node.js is older than 22. Run
node --versionand install Node.js 22 or newer. Your client uses whichevernodeandnpxcome first on its ownPATH, which can differ from your terminal's.No network access.
npxdownloads the package on first run, and every tool call goes tohttps://rivalize.ai(orRIVALIZE_API_URL). Behind a corporate proxy, setHTTPS_PROXY. A network error names the server and the cause code, such asECONNREFUSEDorENOTFOUND.
To see the message directly, run the server in a terminal with the same key:
RIVALIZE_API_KEY=rk_live_... npx -y @rivalize/mcpA healthy server prints rivalize-mcp-server connected via stdio to stderr
and waits for input (press Ctrl+C to stop). Anything else is the reason your
client could not connect.
Every call returns 401
The key was rejected by the server it was sent to, and the error names that
server. Check that the key has not been revoked, and that RIVALIZE_API_URL is
unset unless the key was issued by a different Rivalize server.
A tool says it needs a higher plan
Reads are available on every plan. Some capabilities, such as battlecards and full timeline or landscape history, need a higher plan; the error says which and links to rivalize.ai/pricing.
Docker
The repository includes a Dockerfile that builds the same stdio server on
Node 22 and runs it as a non-root user.
docker build -t rivalize-mcp .{
"mcpServers": {
"rivalize": {
"command": "docker",
"args": ["run", "-i", "--rm", "-e", "RIVALIZE_API_KEY", "rivalize-mcp"],
"env": { "RIVALIZE_API_KEY": "rk_live_..." }
}
}
}Run the container with -i and without a TTY, since MCP uses stdin and
stdout. -e RIVALIZE_API_KEY with no value passes the key through from the
client's environment, so it never appears on the docker run command line.
Add -e RIVALIZE_API_URL or -e RIVALIZE_MCP_ALLOW_WRITES the same way if you
need them.
Privacy Policy
This server is a thin client for the Rivalize API.
What it sends, and where. Each tool call becomes an HTTPS request to the Rivalize API at
https://rivalize.ai, or the origin you set inRIVALIZE_API_URL. A request carries your API key as a Bearer token, aUser-Agentofrivalize-mcp/<version>, and the tool's arguments: for example a company domain, a search term, a project, report or competitor id, and, with writes enabled, the competitor URLs you add. If you setHTTPS_PROXYorHTTP_PROXY, requests go through that proxy. Nothing is sent anywhere else.What it does not send. No telemetry, analytics or crash reports. It does not read files on your machine, your conversation, or other tools' output; it sees only the arguments your MCP client passes to its own tools.
What it stores locally. Nothing. It writes no files, keeps no cache and holds no state between runs. Your key lives in your MCP client's configuration, not in this server. Diagnostic messages go to stderr, which your MCP client may log; they never include your API key.
What Rivalize does with requests. The API processes them under the Rivalize Privacy Policy at rivalize.ai/privacy. Rivalize is operated by Downshift LLC, the data controller for that data. Privacy questions go to privacy@rivalize.ai.
Security
Please report vulnerabilities privately to support@rivalize.ai with
"security" in the subject line, not in a public issue. Include the package
version (npm view @rivalize/mcp version, or the User-Agent above), what you
did, and what happened. We will acknowledge your report and keep you updated
until it is resolved.
Treat your API key as a credential. Keep it in your client's env block or
your shell environment, never in a shared or committed file, and revoke a
leaked key under Settings → API Keys.
Contributing
Bug reports and feature requests are welcome at github.com/Downshift/rivalize-mcp/issues. For account and billing questions, email support@rivalize.ai.
To work on the server locally:
npm ci
npm run typecheck
npm run build # emits dist/, which the rivalize-mcp bin runs
npm test # offline: every API call is mocked or served by a local fixtureserver.json is the MCP Registry
entry. The tests validate it against the official schema (vendored in
schema/) and check that its name, version and package match package.json.
Changelog
0.5.1
README,
llms-install.md, directory listings andserver.jsonnow lead with the Agent plan ($70 a year or $9 a month: 3 competitors at once, refreshed every 7 days, everything collected as JSON, access to the universe of already-collected companies, 500 API and MCP calls a day). No change to the tools.
0.5.0
New
run_report, a write tool (opt-in withRIVALIZE_MCP_ALLOW_WRITES=1). It starts a real report that uses your credits, so it works in two steps: withoutconfirmit starts nothing and returns a preview of the depth, competitors, credits it will use and what you have left; withconfirm: trueit starts the run. The API limits runs to 3 a day per account and returns the run already started for the same request within 10 minutes.New
get_report_statusto check whether a started report has finished.get_reportnow reports figures the fabrication check could not match to a source as(not confirmed in the pages read)instead of removing them.
0.4.0
Agent plan tools:
list_agent_competitorsandget_agent_competitor(reads) andset_agent_competitor(a write, opt-in) for the three tracked-competitor slots of an Agent plan.Every tool result is marked as AI-generated: a top-level
ai_generatedandai_disclosurein JSON results, a closing disclosure line on Markdown results, and_meta.ai_generatedon all of them. Errors are left unchanged.
0.3.2
list_competitorsnow tells your assistant how to pick a top competitor: by the rival's standing on your Brief (brief.standing) when the API returns it, otherwise bymomentum_score.threat_levelis described as what it is, the band of the momentum score, and is no longer offered as a ranking.When a row's standing is still being read (
brief.stateisdeferred),list_competitorsasks for the same page again, up to 4 times, 1.5 seconds apart. Against an API that returns nobrief, it makes one request per call as before.Clearer wording in the 401 hint for a self-hosted or non-production Rivalize server, and in the
add_competitordescription.
0.3.1
The version this repository's history starts from: thirteen read-only tools, the opt-in
add_competitorwrite tool, responses kept under 25,000 characters with explicit paging, proxy support, and the MCP Registry entry inserver.json.
License
MIT, © 2026 Downshift LLC. See LICENSE.
Available Tools
16 toolsget_agent_competitorGet a tracked competitor's collected data (Agent plan)ARead-onlyIdempotent
Read the raw data Rivalize collected about one competitor in your Agent plan, by data group (core: website pages, pricing page, App Store reviews, social profiles; ads_seo: paid ads, search and traffic; extended: everything else collected). Each module carries its source, status and collected_at. There is NO analysis in it: the reasoning is yours. Reading is free and calls no vendor.
Args:
competitor_id (string, required): the competitor id from list_agent_competitors (its domain)
group (string, optional): core | ads_seo | extended; only that group
Returns JSON: { data: { id, name, url, slot, level, collection_status, collected_at, next_refresh_at, groups: { : { modules: { : { status, source, collected_at, data, error } } } }, not_in_plan: { : { code, message } } } }. A group your plan level does not include is absent from groups and named in not_in_plan with code agent_module_not_in_plan. collection_status "pending" means the first collection has not finished yet.
Use when: "what does charge?", "what ads is running?", "read everything you have on ".
Inputs: competitor_id (required), group.
get_battlecardGet competitor battlecardARead-onlyIdempotent
Get the cited sales battlecard for one tracked competitor — Why We Win, Their Weaknesses, Objection Handlers, Discovery Questions. Every claim carries citations resolving to the collected source; claims that could not be cited were WITHHELD, not asserted.
Args:
competitor_id (string, required): the competitor UUID (from list_competitors)
Returns JSON: { data: { status, sections_empty, sections_locked, withheld_reason?, battlecard, markdown, generated_at, intelligence_date, source, report_id?, report_date? } }.
status is read off the card's four sections. "ready": every section carries a cited claim. "partial": at least one section has none; sections_empty names them (sections_locked names the ones locked until the user's company profile is complete, which were not withheld). "withheld": the card exists but no section carries a claim; withheld_reason says why. Do not treat "partial" or "withheld" as a complete card.
"markdown" is a paste-ready cited card and states a partial or withheld card up front. source "generated" is a card generated from the dashboard's Battlecard tab; source "report" is the battlecard inside the competitor's latest report, and report_id names that report (get_report reads it in full).
status "not_generated": no card can be served — none generated, and the latest report has none (or only one in an older format that fails the citation contract). The user generates one from the dashboard's Battlecard tab.
Requires a Pro-plan API key (403 PLAN_REQUIRED below Pro). 404 if the competitor is not in your account (tenant isolation).
Use when: "give me sales ammo against ", "how do we win vs ", or prepping a call.
Inputs: competitor_id (required).
get_competitive_landscapeGet competitive landscapeARead-onlyIdempotent
Get the current or stored weekly competitor positions on activity × strategic importance.
Args:
project_id (string, required): the project's UUID. Call list_projects first for the id.
week (YYYY-MM-DD, optional): a stored ISO week; omit for current positions. The json format lists stored weeks in availableWeeks.
format ("markdown" | "json", optional): markdown by default; json for the full structure
page (number, optional): 1-based page when the Markdown is over 25,000 characters; each page names the next call
Returns agent-ready Markdown by default (JSON on request) with coordinates, trailing signal counts, momentum, latest headlines, importance source, available weeks, and the honest tracking-start date. Historical weeks are never synthesized. History requires Pro; the current view remains available below Pro.
Use when: "who is the biggest moving threat?" or "who moved most this month?".
Inputs: project_id (required), page, week, format.
get_competitor_intelligenceGet competitor intelligenceARead-onlyIdempotent
Get the latest stored intelligence for one tracked competitor.
Args:
competitor_id (string, required): the competitor UUID (from list_competitors)
Returns JSON: { data: { competitor_name, momentum_score, intelligence, latest_snapshot, source, source_report_id, source_report_date, report } }. source says where the data comes from: "snapshot" (a stored intelligence snapshot), "report" (the competitor's latest report in your account; report holds swot, strengths, weaknesses, key_findings, tech_stack, pricing_tiers, social and reviews, and source_report_id names the report for get_report), or "none" (the competitor appears in no snapshot or report yet). Every field is present only when measured: null or absent means "not measured", not "none". Claims the report withheld as unverified are withheld here too.
Returns a 404 error if the competitor does not belong to your account (tenant isolation).
Use when: "what's the latest intel on ?" after finding its id via list_competitors. For the full narrative, get_report with competitor is richer.
Inputs: competitor_id (required).
get_evidenceGet evidenceARead-onlyIdempotent
The sources behind the facts for ONE subject: your own product (omit competitor_id) or one tracked competitor. Taken from the latest readable report in the project that analysed the subject, as the report serves it: claims the report withholds as unverified are withheld here too, and a figure the report has corrected shows the corrected value.
Args:
project_id (string, required): the project's UUID. Call list_projects first for the id.
competitor_id (string, optional): a competitor UUID from list_competitors (it must be in this project). Omit for your own product.
Returns JSON: { data: { project_id, subject: { kind ("product" | "competitor"), competitor_id, name, website }, report: { id, created_at } | null, source_count, unlinked_attributions, off_entity_withheld, sources: Source[] } }. Each Source: url, supports (what it backs: the fact, claim or section, as the report states it), kinds (attribution, page_read, press, strength_receipt, fact, battlecard, interpretation), observed_at (the date of the report run that read it) and, for press, published_at (the article's own date). unlinked_attributions counts data points the report attributed to a description rather than a URL; they are not listed, and no URL is made up for them. off_entity_withheld counts sources a web search for the subject's name returned that are not about the subject (not on its domain, and neither the URL nor any text the report keeps for it names the subject, e.g. a stock page for a similarly named company); they are not listed. With no readable report on the subject, sources is empty and note says why.
Returns a 404 error if the project is not in your account, or if competitor_id is not a competitor in this project (another account's competitor is reported exactly like one that does not exist).
Use when: "where does that come from?", "show me the sources for 's pricing", or to cite a claim.
Inputs: project_id (required), competitor_id.
get_freshnessGet data freshnessARead-onlyIdempotent
How current your Rivalize data is for one project: the date of its latest report, and for EACH tracked competitor the date Rivalize last actually observed it and how. Reading is free; this never fetches anything.
Args:
project_id (string, required): the project's UUID. Call list_projects first for the id.
Returns JSON: { data: { project_id, project_name, latest_report: { id, created_at, depth } | null, competitors: Competitor[], observation_kinds } }. Each Competitor: competitor_id, name, website, status ("observed" or "never_observed"), last_observed_at, last_observed_by, and observations with the newest date of each kind:
report_run: a report you can read analysed it and its crawl read the site (report_id names the report)
site_crawl: a stored crawl of its site
monitoring_page_capture: a monitoring check fetched one of its pages (page_type, url)
search_check: a monitoring search asked whether anything changed. It does not read the site, so it never sets last_observed_at. last_observed_at is the newest of report_run, site_crawl and monitoring_page_capture, and last_observed_by names which. A competitor nothing has observed is "never_observed" with null dates: no date is ever estimated or filled in, and a record's edit time is never used as an observation date. A failed crawl, a rejected report and a baseline copied from stored data are not observations.
Returns a 404 error if the project is not in your account.
Use when: "how fresh is this data?", "when did we last look at ?", or before relying on a figure, to say how old it is.
Inputs: project_id (required).
get_reportRead a reportARead-onlyIdempotent
Read one competitive-intelligence report as Markdown: TL;DR, biggest threat, your blind spots, a section per competitor, and cited battlecards where the report has them.
A figure the report's fabrication check could not match to a source is kept with "(not confirmed in the pages read)" after it, and a name or citation it found to belong to another entity is taken out, exactly as in the report itself. Do not try to fill them in.
Args:
report_id (string, required): the report id (or its job id) from list_reports
section (string, optional): only this named section, plus the report title, date and depth, and a line naming the report's other sections. A whole report is several thousand to over a hundred thousand characters and a section is typically a sixth of it, so ask for the section your question needs. Sections: tldr, biggest-threat, blind-spots, actions (what your product should do), battlecards, competitors (every competitor's section in full); per competitor, gathered from every competitor's section: pricing, momentum, app-store, strengths, weaknesses, key-findings, creators, ads, tech-stack. A report has only the sections it has data for. A name that is not one of this report's sections is an error that lists the sections it does have; retry with one of them. Case, spaces and underscores are ignored ("Key findings" = key-findings).
competitor (string, optional): only the sections whose heading names this competitor (its section and its battlecard), plus the report title and date. Case-insensitive. With section, only that competitor's part of the section (e.g. section "pricing" + competitor "Notion").
page (number, optional): 1-based page. A report over 25,000 characters is split into pages at section boundaries; every page starts with "Page N of M", the characters that remain, the exact call for the next page, and the sections on later pages. A report that fits is returned whole, unchanged.
Without section, returns the whole report exactly as before. Returns Markdown. 404 if the report is not in your account or is not available.
Use when: "summarise my latest report" (no section, or tldr), "what do competitors charge?" (section "pricing"), "what did the report say about ?" (use competitor).
Inputs: report_id (required), page, section, competitor.
get_report_statusCheck a report runARead-onlyIdempotent
Check whether a report started with run_report has finished. Reading is free. A full report takes about 10 to 20 minutes.
POLL NO MORE OFTEN THAN EVERY 30 SECONDS. Each call is counted against your API allowance and the report cannot finish faster; tell the user it is running and check again later instead of calling in a loop.
Args:
report_id (string, required): the report_id from run_report
Returns JSON: { data: { report_id, status, finished, message, ... } }. status: "processing" (still running), "completed", "no_competitors" (finished: a profile of the product alone), or "no_rivals" (stopped before any research because no competitor could be counted as a rival; no credits were used). The API does not report a percentage: status is all there is. When finished is true the result names the next call: get_report with the report_id.
Use when: "is my report ready?" after run_report.
Inputs: report_id (required).
get_strategic_timelineGet strategic timelineARead-onlyIdempotent
Get a receipt-linked timeline of competitor activity across Pricing, Product, People, Funding, and Content/Social lanes.
Args:
project_id (string, required): the project's UUID. Call list_projects first for the id.
days ("30" | "90" | "180", optional): history window, default 90
competitor_id (string, optional): isolate one competitor
lanes (string[], optional): only these lanes, any of pricing, product, people, funding, content-social
format ("markdown" | "json", optional): markdown by default (compact); json for the full structure
page (number, optional): 1-based page of the Markdown. A timeline over 25,000 characters is split at lane/move boundaries; each page says "Page N of M", what remains and the exact next call.
Returns agent-ready Markdown by default (JSON on request) with structured events, seven-day move clusters, tracking-since dates, and evidence URLs. History is never backfilled before Rivalize began tracking. Full history/all-competitor access requires Pro; lower plans can request one competitor for 30 days.
Use when: "what strategic moves have competitors made this quarter?" or "show the arc behind recent competitor activity".
Inputs: project_id (required), days, page, lanes, +2 more.
get_universe_companyGet universe companyARead-onlyIdempotent
Get the universe profile for one company by domain, including every populated intelligence layer (identity, pricing, features, ads, social, reviews, funding/hiring, rankings, signals, momentum).
Args:
domain (string, required): the company domain or any URL on it (e.g. "linear.app" or "https://linear.app/pricing"). Normalized server-side.
layers (string[], optional): only these layers — any of identity, pricing, features, ads, social, reviews, funding_hiring, rankings, signals, momentum. Asking for fewer layers returns more items of each.
Returns compact JSON: { data: { domain, name, primaryCategory, lastEnrichedAt, layerFreshness, identity, pricing, features, ads, socialInfluencers, reviews, fundingHiring, rankings, signals, momentum, ... } }. Long arrays (recent posts, ad creatives, sources) are capped; _capped lists kept/total for each. If a layer still does not fit, it is left out and listed in _omitted with the exact call that fetches it. The JSON is always complete and valid.
If the domain is not in the universe, says so (and, when the domain is one of your tracked competitors, points at get_competitor_intelligence / get_report instead).
Use when: "give me everything Rivalize knows about ".
Inputs: domain (required), layers.
list_agent_competitorsList tracked competitors (Agent plan)ARead-onlyIdempotent
List the competitor slots of your Rivalize Agent plan: who is tracked, when each was last collected, when it refreshes next, and how many slot changes are left this calendar month. Reading is free and calls no vendor. Only Agent plan keys use this; other plans use list_competitors.
Args: none.
Returns JSON: { data: { level, plan, slots_total, slots_used, refresh_days, slots: [{ slot, competitor: { id, name, url } | null, collection_status, last_collected_at, next_refresh_at, changes_left_this_month, changes_reset_at }] } }. Use competitor.id with get_agent_competitor.
Use when: "which competitors am I tracking?", "when does my data refresh?", "can I swap a competitor?".
Inputs: no named parameters.
list_competitorsList tracked competitorsARead-onlyIdempotent
List the competitors tracked in YOUR Rivalize account (tenant-isolated). Answers "which competitors am I tracking?".
Args:
project_id (string, optional): only one project's competitors. Call list_projects first for the id.
limit (number, optional): page size 1-100
offset (number, optional): pagination offset (default 0)
Returns JSON: { data: Competitor[], pagination: { total, limit, offset, returned, next_offset } }. Each Competitor includes id, project_id, project_name, name, website, threat_level, momentum_score, and brief where the server provides it. Keep paging with offset = pagination.next_offset until it is null.
momentum_score is the rival's momentum score, and threat_level is only that score's band (critical, high, medium, low, or unknown when there is no score): it is not a second assessment, so do not rank by it.
brief, when present, is how the rival stands as your workspace's Brief shows it: brief.standing is "ahead" (the rival is ahead of you), "behind", "even" or "no_read"; brief.standing_label is the Brief's own words; brief.as_of is the date of the report it was read from; brief.state is "read", "not_in_run" (no finished report covered this rival), "no_run", "unreadable" or "deferred" (still being read: the tool asks again a few times before it answers, so a row still "deferred" means call again in a moment).
To pick the "top" or biggest competitor: rank by brief.standing when present ("ahead" first, then "even", then "behind"), otherwise by momentum_score; break ties by highest momentum_score. A rival whose brief.state is not "read" has no standing yet: say so rather than ranking it by standing.
With a competitor's id: get_competitor_intelligence (its latest intelligence), get_battlecard (sales battlecard), get_evidence with its project_id (the sources behind its facts). For what a report said about it: list_reports for the project, then get_report with competitor set to its name. For when it was last observed: get_freshness for its project.
Use when: "which competitors am I tracking?", "who is my top competitor?", or before any per-competitor read.
Inputs: limit, offset, project_id.
list_projectsList projectsARead-onlyIdempotent
List the projects in YOUR Rivalize account. A project is one of your products and the competitors tracked against it.
Args: none.
Returns JSON: { data: Project[] }. Each Project includes id, name, url, competitor_count, last_refreshed_at, created_at.
Use the returned project id with list_competitors, list_reports, get_strategic_timeline, get_competitive_landscape, get_freshness and get_evidence.
Use when: "what products/projects do I have?", or first, whenever another tool needs a project_id. (For "which competitors am I tracking?" use list_competitors.)
Inputs: no named parameters.
list_reportsList reportsARead-onlyIdempotent
List the competitive-intelligence reports in YOUR Rivalize account, newest first. Reading is free; this never generates a report.
Args:
project_id (string, optional): only this project's reports. Call list_projects first for the id.
limit (number, optional): page size 1-100 (default 20)
offset (number, optional): pagination offset (default 0)
Returns JSON: { data: Report[], pagination: { total, limit, offset, returned, next_offset } }. Each Report includes id, job_id, project_id, product_name, product_url, competitor_urls, status ("completed" or "unavailable"), created_at, depth ("full" for full research, "quick" for a quick check). A quick check does not buy search traffic, follower counts or the written note on each company, so those are blank in it and marked "Needs full research"; they are not findings.
Use the returned id with get_report.
Use when: "what reports do I have?" or "open my latest report on ".
Inputs: limit, offset, project_id.
list_universe_companiesList universe companiesARead-onlyIdempotent
List companies from the Rivalize universe — the cross-customer competitive-intelligence dataset (not your own tracked competitors; for those use list_competitors).
Search by keyword, filter by category or by which intelligence layer is populated, and paginate.
Args:
q (string, optional): search name/domain/description
category (string, optional): category SLUG, e.g. "ai-infra" (names like "AI infrastructure" do not match; each row's categories lists its slugs)
layer (string, optional): require a populated layer — one of identity, pricing, features, ads, social, reviews, funding_hiring, rankings
limit (number, optional): page size 1-100 (default 50)
offset (number, optional): pagination offset (default 0)
Returns compact JSON: { data: Company[], pagination: { total, limit, offset, returned, next_offset }, filters }. Each Company: domain, name, primaryCategory, categories (slugs), priorityScore, lastEnrichedAt, layers (which layers are populated), layersUpdated, description (at most 120 characters). If a page does not fit one response, fewer rows come back with _truncated, and pagination.limit/returned say how many; always continue with offset = pagination.next_offset (null when there are no more). Use get_universe_company for one company's full profile.
Use when: "who are the players in ?" or "show me universe companies matching ".
Inputs: q, layer, limit, offset, +1 more.
teardown_competitorTear down a competitorARead-onlyIdempotent
Produce a full strategy teardown of one competitor by domain — their positioning/hooks, pricing, ads (the creatives they are running), social presence, reviews, hiring, momentum, plus weaknesses to attack. Returns a ready-to-read Markdown teardown, not raw JSON.
This is the one-call competitor teardown: broader than an ad-only teardown, source-backed, and dated (it leads with when the data was last refreshed). Use it to answer "tear down " or "what is 's strategy and where are they weak?".
Args:
domain (string, required): the competitor's domain or any URL on it.
Returns Markdown. Ads count as active only if seen in the last 30 days; an unscored momentum is shown as not scored. If the domain is not yet in the universe, says so: when it is one of your tracked competitors it points at get_competitor_intelligence / get_report, otherwise at how to get it enriched.
Inputs: domain (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 16 tools
Descriptions are unusually explicit and cross-reference each other (e.g. list_competitors vs list_agent_competitors, get_competitor_intelligence vs get_universe_company vs teardown_competitor), so an agent has strong guidance. However there is genuine surface overlap: two competitor-listing tools split by plan, and several tools that all return competitor info could still be misselected when the agent's plan/report state is unknown.
Nearly all tools follow a clean snake_case get_/list_ verb_noun pattern (list_projects, get_report, get_freshness, get_competitive_landscape). Minor deviations like teardown_competitor (verb without a get_/list_ prefix) and the abstract get_freshness keep it from being perfect.
16 tools is at the upper edge but justified by the multi-tier design (own account, Agent-plan raw data, cross-customer universe, reports, battlecards). Each group maps to a distinct capability, so the count is reasonable rather than inflated.
The surface is read-heavy: get_report_status explicitly references a run_report to start reports, yet no such tool exists, so generation is a dead end. There is also no tool to add/remove/track competitors or create projects, leaving notable gaps in the lifecycle even though read/coverage is rich.
Maintenance
Related MCP Connectors
Competitive intelligence MCP server for Claude and ChatGPT. Ripplewatch tracks your competitors' pricing, hiring, product launches, press and reviews, gives each one a Momentum score from -100 to +100, and checks every move against your own won and lost deals. Ask what changed this week, which competitor is heating up, or what is costing you deals, and log a deal just by telling it. Works in any assistant that supports remote MCP.
Competitor intelligence for AI agents — SEO, traffic, social, Product Hunt, pricing, AI insights.
Competitor intelligence for AI agents — SEO, traffic, social, Product Hunt, pricing, AI insights.
Track competitors from your AI assistant: change feed, page snapshots, labels and alerts.
Related MCP Servers
- AlicenseAqualityBmaintenanceCompetitive intelligence platform with 24 tools. Monitor competitor pricing, content, positioning, tech stacks, and AI visibility — track how ChatGPT, Claude, and Gemini rank your brand.483MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to perform real-time business intelligence tasks including competitive analysis, website scoring, review analysis, and market research.MIT
- AlicenseAqualityBmaintenanceTrack competitors, run discovery, read the interpreted change feed, triage items, and pull workspace digests without leaving your AI client.2090 npmMIT
- AlicenseNot gradedqualityCmaintenanceRemote MCP server that lets AI assistants read tracked competitive intelligence — competitor news, reviews, website changes, social posts and ads — and act on it by managing projects, competitors, battle cards, reports and canvases. Every answer carries a source and a date, and write actions only publish when explicitly shared.MIT