Rivalize MCP Server
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| RIVALIZE_API_KEY | Yes | Your Rivalize API key (rk_live_...), created at rivalize.ai under Settings, API Keys. | |
| RIVALIZE_API_URL | No | Optional. Origin of the Rivalize API that issued the key. Leave unset for rivalize.ai. |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": true
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| list_universe_companiesA | 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:
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 ". |
| get_universe_companyA | 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:
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 ". |
| teardown_competitorA | 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:
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. |
| list_projectsA | 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.) |
| list_reportsA | List the competitive-intelligence reports in YOUR Rivalize account, newest first. Reading is free; this never generates a report. Args:
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 ". |
| get_reportA | 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:
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). |
| list_competitorsA | List the competitors tracked in YOUR Rivalize account (tenant-isolated). Answers "which competitors am I tracking?". Args:
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. |
| get_competitor_intelligenceA | Get the latest stored intelligence for one tracked competitor. Args:
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. |
| get_battlecardA | 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:
Returns JSON: { data: { status, sections_empty, sections_locked, withheld_reason?, battlecard, markdown, generated_at, intelligence_date, source, report_id?, report_date? } }.
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. |
| get_strategic_timelineA | Get a receipt-linked timeline of competitor activity across Pricing, Product, People, Funding, and Content/Social lanes. Args:
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". |
| get_competitive_landscapeA | Get the current or stored weekly competitor positions on activity × strategic importance. Args:
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?". |
| get_freshnessA | 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:
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:
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. |
| get_evidenceA | 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:
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. |
| list_agent_competitorsA | 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?". |
| get_agent_competitorA | 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:
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 ". |
| get_report_statusA | 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:
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. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
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.