Documentation

How to connect your AI agent to KeyVex and query the 60+ tools. The open MCP endpoint needs no account or API key: point your MCP client at it and try two datasets. A free account opens most of the catalogue, and paid plans (Basic, Pro, Business) open every tool with higher limits (see below).

What is KeyVex

KeyVex is a public-data API for US financial and government disclosures: SEC filings, congressional trades, FEC campaign finance, federal contracts and grants, lobbying, regulatory enforcement, sanctions, macroeconomic indicators, and more. It's built agent-first and delivered as a remote Model Context Protocol (MCP) server, so any MCP client, Claude, Cursor, or your own agent, connects once and can query all 60+ tools with no glue code. And because the endpoint is plain HTTP, you can also call it directly with curl or any HTTP client, which is handy for non-agent, programmatic use.

Disclosure data is public-record information sourced from US government agencies; market price data is licensed from Tiingo (Terms §6). KeyVex normalizes and indexes it; KeyVex does not provide investment, legal, tax, or compliance advice, derived signals, or trading recommendations.

Quickstart

1. Try it with no signup, two datasets are open

KeyVex's public MCP endpoint needs no account, no API key and no consent flow. Point your client at the URL below and start calling. The open endpoint serves two datasets so you can evaluate KeyVex before creating anything:

• get_congressional_trades, stock trades disclosed by members of Congress
• get_insider_transactions, SEC Form 3/4/5 insider buys and sells

Every other dataset returns a short message telling you to create a free account. A free account costs nothing and unlocks most of the catalogue. Fifteen tools need a paid plan (Basic and up): the two market-data feeds, unified_search, and twelve of the heaviest datasets. Each one is marked in the tool reference. See Accounts & tiers.

2. Choose your AI

KeyVex has two MCP endpoints. Both speak the same protocol; they differ in what they will serve you:

https://mcp.keyvex.com        # open endpoint, no account; 2 datasets, 60 calls/day per IP
https://mcp.keyvex.com/pro    # sign in with your KeyVex account; your plan's datasets, quota + history

Pick your client for step-by-step setup:

Claude ChatGPT Cursor Windsurf VS Code

Using something else? Any client that speaks MCP's standard Streamable HTTP transport works, point it at https://mcp.keyvex.com; the free endpoint needs no authentication headers.

KeyVex is also listed on Smithery, which can install it into your client for you.

claude mcp add --transport http keyvex https://mcp.keyvex.com

claude mcp add --transport http keyvex https://mcp.keyvex.com/pro \
  --header "Authorization: Bearer kvx_live_YOUR_KEY"

{
  "mcpServers": {
    "keyvex": {
      "url": "https://mcp.keyvex.com/pro",
      "headers": { "Authorization": "Bearer kvx_live_YOUR_KEY" }
    }
  }
}

{
  "mcpServers": {
    "keyvex": {
      "serverUrl": "https://mcp.keyvex.com/pro",
      "headers": { "Authorization": "Bearer kvx_live_YOUR_KEY" }
    }
  }
}

{
  "servers": {
    "keyvex": {
      "type": "http",
      "url": "https://mcp.keyvex.com/pro",
      "headers": { "Authorization": "Bearer kvx_live_YOUR_KEY" }
    }
  }
}

3. Make a query

Ask your agent something that touches KeyVex data:

"Show me the largest congressional trades in the past 30 days
 with party and committee context."

The agent will pick the right tools (get_congressional_trades and get_member_profile), run them in parallel, and synthesize an answer.

4. Verify with curl (optional)

You can hit the endpoint directly without any client. Health check:

curl https://mcp.keyvex.com/

Returns server version, tool count, and the full tool list as JSON. List all tools via MCP:

curl -X POST https://mcp.keyvex.com/ \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

No Authorization header is needed. The response is a JSON-RPC envelope containing the full schema of every tool.

Authentication, accounts & tiers

The free endpoint stays open because every tool serves data already public by federal mandate (SEC filings, USAspending records, congressional disclosures, etc.), there's nothing user-specific to gate on, and skipping auth removes a setup step for the agent developer.

Abuse prevention. Because the free endpoint is open, two mechanisms protect it from runaway use:

• A per-IP rate limit caps each calling IP at 60 requests per 60-second sliding window. Exceed it and the endpoint returns HTTP 429 with a Retry-After header.
• A Cloud Run instance cap bounds the worst-case server load even under a coordinated flood.

Accounts & higher tiers. You can create a free account at keyvex.com (email, Google, or phone) and we'll issue you an API key, keys are stored only as a hash, never in the clear. Your account's plan (Free / Basic / Pro / Business) sets which tools you can call, your daily calls, monthly data and history window on both the REST API and the /pro MCP endpoint below. The free public endpoint at mcp.keyvex.com stays authless and free.

Use your plan in Claude, the /pro connector

To use your KeyVex account's tier through Claude (or any OAuth-capable MCP client), connect to the account-aware endpoint instead of the public one:

https://mcp.keyvex.com/pro

Here's the flow, step by step:

• 1. Add the connector. In Claude's Connectors settings, add a custom connector pointing at https://mcp.keyvex.com/pro. It connects immediately, the tool list loads without signing in.
• 2. Sign in on first use. The first time Claude actually calls a tool, it shows an inline Connect card. Click it, sign in with your KeyVex account (the same login as keyvex.com), and Claude retries the call automatically. One-time step per client.
• 3. Your plan applies live. Every call is metered at your account's current tier, daily quota and history window (Free: 1 year · Basic: 5 years · Pro and Business: full archive). A plan change applies from your next call once it takes effect: an upgrade at once, a lower plan at the end of the period you've paid for. There's nothing to reconnect or refresh.

Prefer your API key? Header-capable clients, Claude Code, Cursor, scripts, can skip OAuth entirely and send the same kvx_live_ key you use on the REST API, as either header:

# Claude Code
claude mcp add --transport http keyvex https://mcp.keyvex.com/pro \
  --header "Authorization: Bearer kvx_live_YOUR_KEY"

# or raw HTTP, x-api-key works too
curl -X POST https://mcp.keyvex.com/pro \
  -H "x-api-key: kvx_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_congressional_trades","arguments":{"ticker":"NVDA"}}}'

An expired or invalid credential returns 401, Claude responds by refreshing its token or re-showing the Connect card, so a stale session heals itself. With a key on /pro, you can call every tool your plan includes (Free leaves out fifteen, marked in the tool reference); quota and history depth follow your plan too. The open endpoint is the one that differs: without a key it serves two datasets, as described in Authentication, accounts & tiers.

REST API (HTTP)

Besides the MCP connector, KeyVex exposes the same data as a plain REST API at https://api.keyvex.com, for AI-generated scripts, agents, and apps that make ordinary HTTP requests instead of speaking MCP. If you ask an AI to "build me something with KeyVex," this is the surface its code calls.

Base URL & OpenAPI spec

The machine-readable OpenAPI 3.1 spec lists every endpoint and parameter, point any AI at it and it can write correct code on the first try:

https://api.keyvex.com/openapi.json

Authentication

The REST API is key-only (unlike the free MCP endpoint). Create a free account at keyvex.com, generate a key, and send it on every request in the x-api-key header:

curl "https://api.keyvex.com/v1/congressional-trades?ticker=NVDA" \
  -H "x-api-key: YOUR_KEY"

Endpoints

All 60+ tools are exposed as GET /v1/<name>, the tool name without the get_ prefix, hyphenated. A few examples:

GET /v1/congressional-trades?ticker=NVDA
GET /v1/insider-transactions?ticker=AAPL
GET /v1/institutional-holdings
GET /v1/federal-contracts
GET /v1/lobbying-filings
GET /v1/material-events

Responses are JSON. Most tools answer as { "results": [...], "count": N, "has_more": bool }; a few have their own shape: get_company_profile returns one company profile, get_intraday_quote one quote, get_daily_prices a price series, and unified_search results grouped by source. See the OpenAPI spec for the full list of endpoints and their parameters. The spec is generated from the live server, so it is always the authoritative count, no number written here can go stale against it.

Tool reference

KeyVex exposes 60+ tools. All are read-only. Every tool's full schema (parameters, filters, response shape) is returned by the MCP tools/list method. The table below is a one-line summary. Tools marked (paid plans) need Basic or higher; a free key cannot call them.

SEC filings & market structure

Congressional activity

Campaign finance & influence

Federal awards

Regulatory & compliance

Macroeconomic & markets

Innovation & IP

Reference & market data

unified_search

unified_search is the cross-source meta-tool. Pass one or more identifiers (ticker, company_name, cusip, company_cik, bioguide_id, recipient_uei) and it fans out across every applicable tool in parallel, returning a unified envelope. It needs a paid plan (Basic and up): a free key cannot call it, and neither can the open endpoint without a key.

Useful when you want a full picture of an entity without manually calling 10 tools:

{
  "method": "tools/call",
  "params": {
    "name": "unified_search",
    "arguments": { "ticker": "NVDA" }
  }
}

The fan-out hits insider transactions, congressional trades, institutional holdings, activist stakes, federal contracts, material events, fundamentals, and more: whichever tools match the identifier you passed. get_lobbying_filings is the one collection deliberately excluded from the fan-out (substring scans on 51K+ filings are too slow to parallelize); call it directly for lobbying queries.

Rate limits

How KeyVex meters usage depends on how you connect.

Authless public endpoint. The open mcp.keyvex.com endpoint needs no account or key, it exists so MCP clients and connectors (for example the Claude Connector, where users can't sign up to test) can call it immediately. Without a key it serves two datasets, and it's rate-limited per IP at 60 requests per 60-second sliding window and 60 tool calls a day. Exceed the window and the endpoint returns HTTP 429 with a Retry-After header indicating how long to wait.

Authenticated tiers. Create an account and send an API key for a higher, per-account daily quota that resets at midnight Eastern:

• Free: 60 calls / day, 100 MB of data / month, most datasets (not market data, unified_search or twelve heavier datasets), 1 year of history, up to 50 rows per call. Up to 30 calls a minute and 3 at once. Logos and member photos: 2 of each a day.
• Basic: 10,000 calls / day, 5 GB of data / month, every dataset including market data, 5 years of history. Up to 300 calls a minute and 5 at once. Intraday quotes: 1,000 a day. Logos: 500 a day. Personal, non-commercial use.
• Pro: 50,000 calls / day, 15 GB of data / month, every dataset, full historical archive. Up to 300 calls a minute and 6 at once. Intraday quotes: 5,000 a day. Logos: 2,000 a day. Personal, non-commercial use.
• Business: 50,000 calls / day, 30 GB of data / month, every dataset, full historical archive. Up to 300 calls a minute and 6 at once. Intraday quotes: 5,000 a day. Logos: 2,000 a day. Commercial use (subject to the federal use restrictions in Terms §6A).
• Enterprise: custom limits and licence terms; contact us.

Whichever limit you reach first applies, and each plan also has a daily server-time budget (currently Free 1 minute, Basic 20 minutes, Pro 90 minutes, Business 3 hours), which wide or slow requests use the most. A request may count as more than one call against the daily allowance. Today most count as one; the exceptions are a boxed logo (2 calls), a member photo (3 calls), and a unified_search sent with a key to the open mcp.keyvex.com endpoint (one call per dataset it searches). These weights are configuration and can change, so the X-KeyVex-Units header on REST, and the result's _meta on MCP, say what each call counted. A refused request says which limit was reached and when it resets: daily limits at midnight Eastern, monthly data on the 1st.

Without an account, the open endpoint serves get_congressional_trades and get_insider_transactions at 60 calls / day per IP, with 1 year of history.

History windows. Time-series datasets return records within your tier's window (Free/keyless: 1 year · Basic: 5 years · Pro and Business: full archive). Every response subject to a window carries a history_floor field plus a history_note so agents always know the range they're seeing. Reference datasets (member profiles, sanctions & screening lists, OIG exclusions, foreign-agent registrations, economic indicators) are always served in full, capping a current-state compliance list would make it wrong, so we don't.

What a refusal looks like. On the REST API, reaching a limit (calls a minute, calls at once, calls a day, a per-tool daily cap, monthly data or daily server time) returns HTTP 429 rate_limited with a Retry-After header: about a minute for the per-minute limit, a few seconds for calls at once, and the time until the reset for daily and monthly limits. Calling a tool your plan does not include returns HTTP 402 upgrade_required with no Retry-After, because waiting will not help. On MCP, the same refusals arrive as HTTP 200 carrying a JSON-RPC error (code -32000) whose message names the limit, with the Retry-After header set wherever waiting helps. The open endpoint's per-IP limit is the exception: it answers HTTP 429. If usage metering is briefly unavailable, REST answers HTTP 503 with a 30-second Retry-After. A server-side concurrent instance cap additionally bounds worst-case load under coordinated traffic; you should never see it unless you're actively trying to flood the server.

For most agent workflows (a few tool calls per user question, the occasional batch catch-up) you'll never hit a limit. To raise your quota or extend your history window, see Accounts & tiers or compare plans.

Data freshness

Two different clocks govern how current a record is, and it helps to keep them separate.

1. Poll cadence, how often KeyVex re-checks each source. KeyVex stores normalized data in Postgres and refreshes it on this schedule (Eastern time):

• SEC Form 4: every 30 minutes, 5 AM to 10 PM
• SEC 8-K, Form 3, Form 144, 13D / 13G: hourly, 5 AM to 10 PM
• 13F: every 4 hours
• Other SEC filings (proxies, registration statements, Form D, N-PORT, tender offers and more): daily
• Congressional trades: every 2 hours, 6 AM to 10 PM
• FEC contributions, federal contracts and grants, lobbying: daily
• Bills and roll-call votes: daily; member profiles: weekly
• XBRL fundamentals: Sunday, Wednesday and Friday at 4 AM
• OFAC and the consolidated screening list: twice daily; recalls: daily; FARA: weekly
• Economic indicators: daily

2. Source-publication lag, how recent the data itself can be. Several agencies publish in batches well after the events they describe, so the newest record a tool can return is bounded by the source's own release schedule, not by how often KeyVex polls. Polling every 30 minutes cannot surface data the SEC has not published yet. The main lagged sources:

• Fails-to-deliver (get_sec_fails_to_deliver): SEC publishes a half-month batch ~2-4 weeks after that half-month closes, so the latest settlement date typically trails today by 2-4 weeks.
• Product recalls (get_product_recalls): FDA / CPSC datasets commonly post 4-6 weeks after a recall is initiated.
• 13F institutional holdings (get_institutional_holdings): funds file quarterly, up to 45 days after quarter-end, a quarterly snapshot, never intraday.
• N-PORT fund holdings (get_fund_holdings, get_nport_filings): monthly filings released on a ~30-60 day public-availability delay.
• Congressional PTRs (get_congressional_trades): members may file up to 30-45 days after a trade, so the disclosure date lags the trade date.

So a record from a few weeks ago on a lagged tool is the source operating normally, not a stale cache. Every tool response, on REST and MCP alike, carries a freshness block: checked_at plus a datasets list where each entry gives last_updated (when the KeyVex job behind it last ran), age_hours, expected_cadence and a status of current, late, stale or unknown. When anything is not current, the block adds a notice saying so. Lagged tools also restate their own publication cadence in the tool description.

Troubleshooting

Support

For privacy, terms, and data-handling questions, see the privacy policy. For status and version, see the public health check at https://mcp.keyvex.com/ (returns server version and current tool list as JSON, no authentication required).