Skip to main content
Glama

Rivalize MCP Server (@rivalize/mcp)

npm License: MIT

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).

  1. 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.

  2. 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.

  3. 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/mcp

Cursor

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

npx

Arguments

-y @rivalize/mcp

Environment

RIVALIZE_API_KEY=rk_live_...

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 (get_battlecard) and 1-year change history.

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

teardown_competitor

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

domain (required)

list_universe_companies

read

Search the Rivalize universe, the cross-customer dataset of tracked companies

q, category (slug), layer, limit (1-100), offset

get_universe_company

read

Full universe profile for one company: identity, pricing, features, ads, social, reviews, funding and hiring, rankings, signals, momentum

domain (required), layers

list_projects

read

The projects in your account; returns the project_id other tools take

none

list_reports

read

Your reports, newest first. Reading never generates a report

project_id, limit (1-100), offset

get_report

read

One report as Markdown, whole or one section or one competitor at a time

report_id (required), section, competitor, page

list_competitors

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

project_id, limit (1-100), offset

get_competitor_intelligence

read

Latest stored intelligence for one tracked competitor; a field is present only when it was measured

competitor_id (required)

get_battlecard

read

Cited sales battlecard for one tracked competitor. Requires a Pro plan

competitor_id (required)

get_strategic_timeline

read

Evidence-linked timeline of competitor moves across pricing, product, people, funding and content/social

project_id (required), days (30, 90, 180), competitor_id, lanes, format, page

get_competitive_landscape

read

Current or stored weekly positions of competitors by activity and strategic importance

project_id (required), week (YYYY-MM-DD), format, page

get_freshness

read

When each tracked competitor in a project was last actually observed, and how

project_id (required)

get_evidence

read

The sources behind the facts for your product or one competitor: URL, what it supports, and when it was read

project_id (required), competitor_id

add_competitor

write, opt-in

Add competitor URLs to a project. Spends credits and queues analysis

project_id (required), urls (1-10, required)

run_report

write, opt-in

Starts a real report that uses your credits (paid dashboard plans; about 10 to 20 minutes). Two steps: without confirm it starts nothing and returns a preview (depth, the project's competitors, the credits it will use, credits and monthly reports left, expected time). With confirm: true it starts the run. depth is full (15 credits per 5 competitors, uses a monthly report) or quick (1 credit per competitor). At most 3 runs a day through the API or MCP per account, and the same request within 10 minutes returns the run already started

project_id (required), depth, confirm

get_report_status

read

Whether a report started with run_report has finished (processing, completed, no_competitors, no_rivals), and the next call. Poll no more often than every 30 seconds

report_id (required)

list_agent_competitors

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

get_agent_competitor

read

Agent plans. The raw data collected about one tracked competitor, by group (core, ads_seo, extended), each module with its source and collected_at. A group your plan does not include is listed under not_in_plan. Your own assistant does the analysis

competitor_id (the domain, required), group

set_agent_competitor

write, opt-in

Agent plans. Put a competitor in a slot, or replace the one in a slot (slot 0-2). Uses no credits and queues a collection. Each slot can be replaced once per calendar month (the refusal gives the reset date); a fourth competitor at once is refused

url (required), name, 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

tldr, biggest-threat, blind-spots, actions

The report's headline sections (actions is what your product should do)

battlecards

The cited sales battlecards

competitors

Every competitor's section in full

pricing, momentum, app-store, strengths, weaknesses, key-findings, creators, ads, tech-stack

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 with Page N of M, how much remains, and the exact call for the next page.

  • Lists (list_universe_companies, list_competitors, list_reports) return pagination.next_offset; continue from it until it is null.

  • 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 _omitted with 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_report with section: "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

RIVALIZE_API_KEY

yes

none

Your Rivalize API key. Must start with rk_live_; the server exits at startup with a message if it is missing or malformed.

RIVALIZE_API_URL

no

https://rivalize.ai

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.

RIVALIZE_MCP_ALLOW_WRITES

no

off

1, true or yes (any case) registers the write tools: add_competitor (spends credits, queues analysis), run_report (starts a real report that uses your credits; preview first, then confirm: true) and set_agent_competitor (Agent plans; no credits). Any other value, or unset, keeps the server read-only.

HTTPS_PROXY / HTTP_PROXY

no

none

Route requests through a corporate proxy. Lowercase forms are also read, and HTTPS_PROXY wins when both are set. NO_PROXY is honoured. Errors name the proxy host, never its credentials.

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:

  1. RIVALIZE_API_KEY is missing or invalid. The log reads rivalize-mcp: RIVALIZE_API_KEY is required, or says the key does not look like a Rivalize API key (it must start with rk_live_). Put the key in the server's env block and restart the client.

  2. Node.js is older than 22. Run node --version and install Node.js 22 or newer. Your client uses whichever node and npx come first on its own PATH, which can differ from your terminal's.

  3. No network access. npx downloads the package on first run, and every tool call goes to https://rivalize.ai (or RIVALIZE_API_URL). Behind a corporate proxy, set HTTPS_PROXY. A network error names the server and the cause code, such as ECONNREFUSED or ENOTFOUND.

To see the message directly, run the server in a terminal with the same key:

RIVALIZE_API_KEY=rk_live_... npx -y @rivalize/mcp

A 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 in RIVALIZE_API_URL. A request carries your API key as a Bearer token, a User-Agent of rivalize-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 set HTTPS_PROXY or HTTP_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 fixture

server.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 and server.json now 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 with RIVALIZE_MCP_ALLOW_WRITES=1). It starts a real report that uses your credits, so it works in two steps: without confirm it starts nothing and returns a preview of the depth, competitors, credits it will use and what you have left; with confirm: true it 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_status to check whether a started report has finished.

  • get_report now 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_competitors and get_agent_competitor (reads) and set_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_generated and ai_disclosure in JSON results, a closing disclosure line on Markdown results, and _meta.ai_generated on all of them. Errors are left unchanged.

0.3.2

  • list_competitors now 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 by momentum_score. threat_level is 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.state is deferred), list_competitors asks for the same page again, up to 4 times, 1.5 seconds apart. Against an API that returns no brief, 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_competitor description.

0.3.1

  • The version this repository's history starts from: thirteen read-only tools, the opt-in add_competitor write tool, responses kept under 25,000 characters with explicit paging, proxy support, and the MCP Registry entry in server.json.

License

MIT, © 2026 Downshift LLC. See LICENSE.

Available Tools

16 tools
get_agent_competitorGet a tracked competitor's collected data (Agent plan)A
Read-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 battlecardA
Read-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 landscapeA
Read-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 intelligenceA
Read-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 evidenceA
Read-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 freshnessA
Read-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 reportA
Read-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 runA
Read-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 timelineA
Read-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 companyA
Read-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)A
Read-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 competitorsA
Read-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 projectsA
Read-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 reportsA
Read-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 companiesA
Read-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 competitorA
Read-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

    A4.2/5.0

    Scored across 16 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count4/5

    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.

    Completeness3/5

    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

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Competitive intelligence platform with 24 tools. Monitor competitor pricing, content, positioning, tech stacks, and AI visibility — track how ChatGPT, Claude, and Gemini rank your brand.
      48
      3
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to perform real-time business intelligence tasks including competitive analysis, website scoring, review analysis, and market research.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Track competitors, run discovery, read the interpreted change feed, triage items, and pull workspace digests without leaving your AI client.
      20
      90 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Remote 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