Government Data MCP Server: SEC + Federal Data for AI Agents
Your AI agent can read a news story about a defense contract. It can't check who won it, what that company filed with the SEC, or how Congress traded the stock. Not because the data is secret, but because nothing hands it to the agent.
A government data MCP server is a Model Context Protocol server that gives an AI agent live access to US federal data as callable tools. Edgrapi runs one at api.edgrapi.com/mcp with 19 tools spanning SEC filings and the four federal sources: contracts, spending, grants, and congressional trades. Connect it to Claude or Cursor, and your agent can pull all of it in one session, on one key.
api.edgrapi.com/mcp with 19 tools spanning SEC filings, insider trades and 13F holdings plus federal contracts, spending, grants and congressional trades. Discovery is open, tool calls need a key, and it connects to Claude, Cursor or Claude Code with one config block. It's the rare server that gives an agent SEC and government data together.What is an MCP server, and why does an AI agent need one?
An MCP server is a service that exposes tools and data to an AI agent through the Model Context Protocol, the open standard Anthropic introduced in November 2024. Think of MCP as a USB-C port for AI: instead of custom glue for every data source, an agent speaks one protocol and any compliant server plugs in. The server offers tools; the agent calls them.
Without MCP, giving an agent new data is a coding project every time.
You write an API client, handle auth, shape the responses, and wire it into the agent's tool layer. Do that for five data sources and you've built five integrations.
With MCP, you paste a URL. The agent reads the server's tool list and starts calling. That's why the ecosystem exploded: by 2026 there are thousands of MCP servers and first-class support in Claude, ChatGPT, Cursor, Gemini, Copilot, and VS Code, per the protocol's own docs.
The catch is coverage. An agent is only as capable as the servers it's connected to, and most data still has no server. Government data is a glaring example.
Is there an MCP server for government and SEC data?
Yes, and it's rarer than you'd think. Plenty of MCP servers cover market prices, and a handful cover SEC filings, but almost none give an agent US government data. Edgrapi's hosted MCP server does both: one endpoint exposes 19 tools covering SEC filings, insider trades, and 13F holdings alongside federal contracts, spending, grants, and congressional stock trades. It's the same public data, turned into agent-callable tools.
That combination is the point.
Market-data servers like Alpha Vantage and Financial Modeling Prep are strong on prices and indicators, but they don't touch federal contracts or congressional trades. SEC-only servers handle EDGAR filings and stop there.
An agent researching a company usually needs both sides of the story. What the company tells the SEC, and what the government pays it. Until now, that meant two separate integrations or none.
Edgrapi puts them behind one MCP endpoint, so the agent doesn't care that SEC data and SAM.gov data come from different systems. It just calls a tool.
What can an agent actually do with it?
It can answer questions that cross datasets in a single session. Because the SEC tools and the government tools live on the same server, an agent can chain them without you writing any glue. Ask it to research a contractor, and it can pull the company's filings, its insider trades, the federal awards it won, and any congressional trading in the stock, then reason over all of it.
Here's the kind of chain that used to be impossible.
An agent starts with a company name, resolves it to a filer, and pulls recent SEC filings and insider transactions.
Then it calls the awards tool to see what federal contracts that company holds, and the opportunities tool to find open solicitations it might bid on.
Then it checks congressional trades in the ticker, to flag whether any House member bought or sold around a relevant event.
None of those steps needs a human to switch tools or paste data between tabs. The agent moves from SEC disclosure to federal spending to congressional activity because all of it is one tool call away.
That's the difference between an agent that can look things up and an agent that can actually investigate.
How do I connect the MCP server to Claude or Cursor?
You add one config block to your MCP client and paste your key. Every MCP-capable client (Claude Desktop, Cursor, Claude Code, Cline) reads the same mcpServers shape, so the setup is a URL plus an authorization header. Point it at https://api.edgrapi.com/mcp, drop in a bearer key, and the agent discovers the tools automatically.
Here's the whole configuration.
{
"mcpServers": {
"edgrapi": {
"url": "https://api.edgrapi.com/mcp",
"headers": { "Authorization": "Bearer edgr_your_key" }
}
}
}That's it. In Cursor you add it to your MCP settings; in Claude Desktop you add it as a connector; in Claude Code it's a single claude mcp add command from your terminal pointing at the same URL. Every client reads the identical config, so switching between them is copy-paste.
Once connected, the agent runs tools/list on its own and sees all 19 tools with their descriptions. You don't teach it what's available. It reads the catalog.
Get a free key first at edgrapi.com/app, paste it into the header, and you're calling federal and SEC data from your agent in a couple of minutes.
How does authentication work for the MCP server?
Discovery is open; calling tools needs a key. An agent can connect and run initialize and tools/list with no credentials, so it can always see what the server offers. The moment it calls a tool with tools/call, it needs a bearer edgr_ key or an OAuth 2.1 token. That split is deliberate: agents can discover the server freely, and only real data pulls are metered.
This matters for how agents behave.
An agent that connects to a new server wants to read the tool list before committing. Open discovery lets it do that without a key, so it can plan.
When it actually pulls data, the key kicks in. You authenticate with a bearer token in the header, or with OAuth 2.1 using PKCE for clients that support the connector flow, like Claude's.
Because the server is in the official MCP registry, compatible clients can also find it through discovery rather than hand-configuration. Either way, the auth model is the same: look freely, pay to pull.
What does an example tool call look like?
Under the hood, every tool call is a JSON-RPC 2.0 message. Your agent sends a tools/call with the tool name and an arguments object, and the server returns normalized JSON. You rarely write this by hand, because the client builds it, but seeing one call makes the protocol concrete: a method, a tool name, and a small set of arguments.
Here's a raw get_congress call.
{"jsonrpc": "2.0", "id": 1, "method": "tools/call",
"params": {"name": "get_congress", "arguments": {"ticker": "NVDA", "limit": 10}}}Send that to api.edgrapi.com/mcp with your bearer key and you get back the House trades in NVDA as structured content.
Your agent assembles this message for you. When you ask it "what did Congress trade in NVDA," it picks the get_congress tool, fills the ticker argument, and sends exactly this.
That's the whole loop. The model chooses the tool and the arguments, the server runs it, and the result comes back as JSON the model can read and reason over.
Can I test the tools without an agent?
Yes. Every MCP tool mirrors a REST endpoint, so you can test the exact same data with plain curl before wiring it into an agent. The get_awards tool maps to /v1/awards, get_congress to /v1/congress, and so on down the list. That lets you verify a query in the terminal, then trust the agent to make the same call through MCP.
This is the fastest way to sanity-check a tool.
curl "https://api.edgrapi.com/v1/congress/NVDA" -H "Authorization: Bearer edgr_your_key"Same data, same key, no MCP client needed. If the REST call returns what you expect, the MCP tool will too, because they run the same code underneath.
So a clean workflow is to prototype the query with curl, confirm the response shape, then connect the MCP server and let the agent call it. You debug in the terminal and ship to the agent.
How do I keep an agent from burning credits?
You control spend the way you would with any metered API: discovery is free, empty results are free, and each tool call costs a small fixed number of credits. An agent that lists tools or gets an empty result pays nothing, so only successful data pulls draw down your balance. A curious agent exploring the catalog doesn't cost you.
A few habits keep it predictable.
Let the agent discover freely. tools/list never costs a credit, so there's no downside to it reading the whole catalog before it starts.
Lean on empty-free billing. A query that returns no data, like a ticker with no congressional trades, costs nothing, so exploratory calls are safe.
Scope the task. The bill tracks how many real pulls the agent makes, so a focused prompt spends less than an open-ended crawl. Metering is per tool call, not per token, so the cost follows data pulled, not thinking done.
What tools does the government data MCP server include?
It exposes 19 tools, split between SEC filings and federal data. The SEC side covers company profiles, financial statements and ratios, filings, 10-K sections, insider trades, 13F holdings, 13D/13G activist stakes, 8-K events, XBRL, shares outstanding, Form D, subsidiaries, and full-text filing search. The government side adds SAM.gov contract opportunities, USAspending awards, Grants.gov grants, and House STOCK Act congressional trades.
Here's the catalog by area.
| Area | Tools |
|---|---|
| Company + financials | get_company, get_fundamentals, get_ratios, get_shares, get_xbrl |
| Filings + disclosure | get_filings, get_sections, search_filings, get_form_d, get_subsidiaries, resolve_entity |
| Smart money (SEC) | get_insider, get_holdings, get_activist, get_events |
| Government data | get_opportunities (SAM.gov), get_awards (USAspending), get_grants (Grants.gov), get_congress (House STOCK Act) |
Each tool returns flat, normalized JSON, so the agent gets structured data it can reason over, not a PDF or a raw filing.
The government tools carry the same honest limits as the underlying endpoints. Congressional trades are House-only for now and never real-time, and USAspending is the daily-downstream copy of federal awards. The tool descriptions say so, so an agent isn't misled about freshness.
How is this different from other financial MCP servers?
The difference is scope: SEC filings plus US government data, not market prices. Most financial MCP servers optimize for quotes, charts, and technical indicators. Edgrapi doesn't do live prices at all. It does disclosure and federal data, which is a different job for a different kind of agent, one that researches and verifies rather than trades on ticks.
Here's the honest split.
| MCP server | Best at | SEC filings | Gov contracts/spending/grants/congress | Live prices |
|---|---|---|---|---|
| Alpha Vantage | Market data breadth | Limited | No | Yes |
| Financial Modeling Prep | Equities + statements | Yes | No | Yes |
| SEC EDGAR MCP servers | SEC filings | Yes | No | No |
| Edgrapi | SEC + federal data | Yes | Yes | No |
Read it by what your agent is for.
Building a trading or charting agent? You want prices, so Alpha Vantage or FMP fits.
Building an agent that researches companies, contractors, or policy exposure, and needs to cite a real filing or a real federal award? That's the SEC-plus-government lane, and combining both on one endpoint is what Edgrapi does that the others don't.
If you only need SEC filings, a single-purpose EDGAR server works too. The moment you also want federal contracts, spending, grants, or congressional trades in the same agent, one server beats stitching four together.
Give your agent the other half of the story
An agent with only market data sees prices. An agent with SEC filings sees disclosure. An agent with both filings and federal data can connect a company to its contracts, its insiders, and its politics, which is where the real research lives. That's the gap this server fills, and it's the reason an investigative agent needs more than a price feed.
If you're building that kind of agent, add the server. Get a free key at edgrapi.com/app, paste the config block into Claude, Cursor, or Claude Code, and let the agent read tools/list. Nineteen tools, SEC plus federal, one endpoint. Start with the question your agent can't answer today, and watch it reach for a tool instead of giving up.
Frequently asked questions
What is an MCP server?
An MCP server is a service that exposes tools and data to AI agents through the Model Context Protocol, an open standard Anthropic introduced in November 2024. Agents connect to the server, read its tool list, and call tools to fetch data or take actions. MCP standardizes those connections so one protocol works across clients like Claude, Cursor, and Claude Code, instead of a custom integration per data source.
Is there an MCP server for SEC and government data?
Yes. Edgrapi runs a hosted MCP server at api.edgrapi.com/mcp with 19 tools covering both SEC filings (company data, insider trades, 13F holdings, 8-K events, and more) and US federal data (SAM.gov contracts, USAspending awards, Grants.gov grants, and House STOCK Act congressional trades). Most financial MCP servers cover market prices or SEC filings alone; combining SEC and government data on one endpoint is the rarer piece.
How do I connect Edgrapi's MCP server to Claude or Cursor?
Add one config block to your MCP client with the URL https://api.edgrapi.com/mcp and an Authorization header holding your bearer key. Claude Desktop, Cursor, Claude Code, and Cline all read the same mcpServers shape. Once connected, the agent runs tools/list automatically and sees all 19 tools. Get a free key at edgrapi.com/app, paste it in, and the agent is calling data in minutes.
Do I need an API key to use the MCP server?
To call tools, yes. Discovery is open, so an agent can run initialize and tools/list with no key and see everything the server offers. Actually pulling data with tools/call requires a bearer edgr_ key or an OAuth 2.1 token. That split lets agents freely discover the server while metering real data pulls. A free key covers exploration, since empty results don't cost a credit.
What tools does the government data MCP server include?
Nineteen tools. The SEC set covers company profiles, fundamentals and ratios, filings, 10-K sections, full-text search, insider trades, 13F holdings, 13D/13G activist stakes, 8-K events, XBRL, shares, Form D, and subsidiaries. The government set adds get_opportunities (SAM.gov), get_awards (USAspending), get_grants (Grants.gov), and get_congress (House STOCK Act trades). Each returns flat, normalized JSON an agent can reason over directly.
Is Edgrapi's MCP server free?
It's free to start and credit-metered after that. You get a free key with monthly credits, and tool discovery (tools/list) is always free and open. Tool calls draw credits based on the endpoint, and empty results don't cost anything, so exploration is free. It's a hosted, metered service rather than an unlimited free feed, running the same public SEC and federal data as clean JSON.