Skip to content
MarketPrior

Developers · MCP server

Diligence and leads as tools for your agent.

MCP (Model Context Protocol) is the open standard AI assistants use to call tools. Point Claude, Cursor or your own agent at one URL and ask for a company’s cited report, start a diligence run, check alerts or search leads in plain language.

16

tools

11

read-only tools

3

metered, confirm-first

2

markdown resources

Connect

One URL, one API key.

Create a key in Settings → API keys and add the server to your client. Every tool call runs as that key’s workspace.

  • Server URL https://marketprior-diligence.fly.dev/mcp
  • Streamable HTTP, stateless — POST only, JSON responses
  • Auth: Authorization: Bearer mp_…
  • Protocol 2026-07-28 per request; 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05 via initialize

Not yet

There is no OAuth sign-in yet, so one-click connector directories can’t add the server. Clients connect with an API key in a header — Claude Desktop through the mcp-remote bridge.

Claude Code · terminal
claude mcp add --transport http marketprior https://marketprior-diligence.fly.dev/mcp \
  --header "Authorization: Bearer mp_..."
Claude Desktop · via mcp-remote
{
  "mcpServers": {
    "marketprior": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://marketprior-diligence.fly.dev/mcp",
        "--header", "Authorization:${MARKETPRIOR_AUTH}"
      ],
      "env": { "MARKETPRIOR_AUTH": "Bearer mp_..." }
    }
  }
}
Cursor · ~/.cursor/mcp.json
{
  "mcpServers": {
    "marketprior": {
      "url": "https://marketprior-diligence.fly.dev/mcp",
      "headers": { "Authorization": "Bearer mp_..." }
    }
  }
}

Your own agent

Python and TypeScript SDKs.

The official MCP SDKs connect over Streamable HTTP with the API key as a bearer header.

python · pip install mcp
import asyncio, os
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def main():
    headers = {"Authorization": f"Bearer {os.environ['MARKETPRIOR_API_KEY']}"}
    async with streamablehttp_client("https://marketprior-diligence.fly.dev/mcp", headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            res = await session.call_tool("search_companies", {"q": "Acme"})
            print(res.content)

asyncio.run(main())
typescript · npm i @modelcontextprotocol/sdk
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(new URL("https://marketprior-diligence.fly.dev/mcp"), {
  requestInit: { headers: { Authorization: `Bearer ${process.env.MARKETPRIOR_API_KEY}` } },
});
const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const { tools } = await client.listTools();
const res = await client.callTool({ name: "search_companies", arguments: { q: "Acme" } });

16 tools

What your agent can do.

Generated from the server’s live tools/list. Each tool needs the API-key scope shown; results are concise, cursor-paginated and size-capped.

Tools exposed by the MarketPrior MCP server
ToolWhat it doesArgumentsScope
search_companiesread-onlyFind a company by name: returns your workspace's companies (with reports), matching companies in MarketPrior's tracked corpus, and not-yet-tracked public-registry candidates (pass a candidate_key to add_company).q, country?, limit?, discover?reports:read
list_companiesread-onlyList the companies in your workspace (each has a diligence report), most recently updated first.q?, limit?, cursor?reports:read
get_company_reportread-onlyGet a company's diligence report: the company, whether the full report is unlocked, the status/freshness of every section, and the requested sections' content (default: the free screen — fused_scorecard, risk_score, upside_score).company_id, sections?reports:read
get_sectionread-onlyGet one report section in full.company_id, sectionreports:read
run_diligencemetered · confirmStart a full diligence run on a company (connector sweep + every section + memo).company_id, deep_dive?, confirm?, quote_id?diligence:run
get_jobread-onlyStatus of a job from run_diligence or refresh_company: queued → running → succeeded | failed.job_idreports:read
refresh_companywrite · freeRefresh an already-diligenced company's stale sections in the background (free — the dashboard's Re-run).company_id, scope?, sections?diligence:run
add_companywrite · freeAdd a company to your workspace so it can be diligenced (free; idempotent by name).name?, domain?, candidate_key?diligence:run
list_alertsread-onlyMonitoring alerts for companies on your watchlist (risk / upside changes), newest first.unacknowledged?, subject_id?, limit?, cursor?reports:read
get_credit_balanceread-onlyRemaining diligence assessments (plan, used, remaining) and lead credits (balance, allowances, unit costs).—reports:read
search_leadsread-onlySearch MarketPrior's company corpus by ICP (geography, industry, size, funding, tech, hiring, recent trigger events, intent score).query?, limit?, cursor?leads:read
lead_trigger_feedread-onlyDated, evidenced trigger events (funding rounds, filings, hiring, launches, ...) across the corpus, newest first, with per-type counts.event_types?, since_days?, countries?, regions?, industries?, min_amount?, company_id?, limit?, cursor?leads:read
list_saved_searchesread-onlyYour saved lead searches and their alert settings.—leads:read
get_company_contactsread-onlyPeople at a corpus company (from search_leads) with title, seniority, affiliation (employee | board) and sources, plus their contact points MASKED.company_idleads:read
reveal_contactmetered · confirmReveal a masked contact point (email/phone) — METERED: spends lead credits (already-revealed contacts are free).contact_id, confirm?, quote_id?leads:reveal
export_leadsmetered · confirmExport lead rows as CSV (max 200 rows per call over MCP; use the REST API for larger exports) — METERED: spends lead credits (rows already exported are free).query?, company_ids?, max_rows?, confirm?, quote_id?leads:export

Guardrails

Built so an agent can’t overspend or overreach.

01

Quote first, then confirm: true

run_diligence, reveal_contact and export_leads return a price quote and a short-lived quote_id unless called with confirm: true and that quote_id — your agent has to ask you first.

02

Same paywall as the app

Paid sections of a locked report come back as report_locked, never as content. The tool descriptions tell the model not to guess what is behind it.

03

Scoped, one workspace per key

Tools take no workspace argument; the key’s scopes decide what works, and the per-key rate limit covers MCP and REST together.
confirm flow · tools/call
→ tools/call  reveal_contact { "contact_id": "…" }
← a credit quote + "quote_id" (valid 10 min) — nothing is spent

→ tools/call  reveal_contact { "contact_id": "…", "confirm": true, "quote_id": "mpq1.…" }
← the revealed contact point (lead credits spent)

Resources

Reports and memos as markdown.

Besides tools, the server exposes resource templates a client can read straight into context.

MCP resource templates
URI templateContents
marketprior://companies/{company_id}/report.mdCompany report (markdown)Verdict, free-screen scores and section status for a company.text/markdown
marketprior://companies/{company_id}/memo.mdInvestment memo (markdown)The cited investment memo (paid report).text/markdown

FAQ

MCP questions.

Building without an agent? Every tool maps to the MarketPrior REST API. See pricing for credits and assessments and the data sources behind each report.

What is an MCP server?
The Model Context Protocol (MCP) is an open standard that lets AI assistants and agents call external tools. The MarketPrior MCP server exposes diligence reports, monitoring alerts and lead search as tools any MCP client can call.
How do I authenticate?
With a workspace API key from Settings → API keys, sent as "Authorization: Bearer mp_…". The key’s scopes decide which tools work; a tool whose scope is missing returns an insufficient_scope error. OAuth sign-in for one-click connectors is not available yet.
Can an agent spend my credits without asking?
Not in one step. run_diligence, reveal_contact, export_leads first return a price quote and a single-use quote_id (valid 10 minutes, tied to your API key and the exact arguments). Nothing is spent until the agent calls again with confirm: true and that quote_id, and these tools are flagged as needing your approval so MCP clients can ask you first. run_diligence only spends an assessment on a company that has never been run; re-runs are free.
Does the agent see locked report content?
No. Paid sections of a report that is not unlocked come back as locked (report_locked), never as content — the same report-access gate the dashboard and REST API use.
Which transport and protocol versions are supported?
Streamable HTTP at https://marketprior-diligence.fly.dev/mcp, stateless: POST only, JSON responses, no session id. Protocol versions: 2026-07-28, 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05.
Is MCP usage rate-limited?
Yes — MCP calls count against the same per-key rate limit as the REST API (120 requests/minute by default).

Give your agent cited diligence.

Start free, create an API key, and add the MarketPrior MCP server to Claude, Cursor or your own agent.