How to give Claude a SEC EDGAR filings-research tool with the Apify MCP server

AI agents are good at reasoning and terrible at facts. Ask Claude for the accession number of Apple's most recent 10-K, or the exact period that filing covers, and it will give you a confident answer from its training data that may be months out of date, or simply invented. For equity, credit, and corporate-development work, "probably the right filing" is not good enough. A citation that points to the wrong accession number is worse than no citation at all.

In this guide we fix that. We connect Claude to the official Apify MCP server, expose a single Actor that reads company filings from the U.S. Securities and Exchange Commission's EDGAR system, and turn "what did they file and when?" from a guess into a live lookup against the source of record. By the end you will have a working filings-research tool that Claude, Cursor, or any MCP client can call during a conversation, and you will understand exactly where in the run the tool fires and what it returns.

Everything below is a real setup with real output. No mocked responses.

What is the Apify MCP server?

Model Context Protocol (MCP) is an open standard that lets AI clients call external tools. The Apify MCP server (https://mcp.apify.com) implements that standard on top of the Apify platform, which means every one of the thousands of Actors in the Apify Store becomes a tool an agent can invoke.

Why route an Actor through MCP instead of hard-coding an API call?

• The agent decides when to fetch. Claude reads the conversation, notices it needs a fact it does not have, and calls the tool on its own. You do not write glue code for every question.
• Structured input and output. The MCP server hands Claude the Actor's input schema, so the model fills in the parameters correctly, and returns a clean dataset it can reason over.
• One connection, many tools. The same MCP endpoint exposes search-actors, fetch-actor-details, and call-actor, so an agent can discover and run any Actor without new configuration.
• No infrastructure. The server is hosted. You add a few lines to a config file and you are done.

The Actor we will use

We will expose the SEC EDGAR 10-K, 10-Q & 8-K Filings Scraper. Give it one or more ticker symbols and a list of form types, and it returns the company's profile plus its filing history: legal company name, ticker, CIK, EIN, state of incorporation, SEC filer category, fiscal year end, business address, phone, any former names, and for each filing the form type, filing date, period-of-report date, accession number, and primary document name.

That field set is exactly what a filings-research or company-diligence workflow needs. EDGAR is a useful first source because it is the authoritative U.S. disclosure system, it is fully public, and it has no login wall.

Step 1: Get your Apify API token

Sign in to the Apify Console, open Settings → Integrations, and copy your personal API token. The MCP server uses it to authenticate and to bill Actor runs to your account.

📌 Note: the token is a secret. Keep it in the client config only, never in a prompt or a committed file.

Step 2: Point Claude Desktop at the Apify MCP server

Open Claude Desktop's config file (Settings → Developer → Edit Config, or ~/Library/Application Support/Claude/claude_desktop_config.json on macOS) and add the Apify server. The tools query parameter is the important part: it tells the server which Actor to expose, so Claude gets one focused tool instead of the entire Store.

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=scrapers_lat/sec-edgar-filings-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}

Cursor uses the same JSON in .cursor/mcp.json. If you prefer to run it locally over stdio instead of the hosted endpoint:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "scrapers_lat/sec-edgar-filings-scraper"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}

Restart Claude Desktop so it picks up the new server.

Step 3: Confirm the tool is loaded

After the restart, the Actor shows up as a callable tool. If you list the tools the Apify server exposes, you will see the storage helpers plus the Actor itself, named after its Store handle:

get-actor-run, get-dataset-items, get-key-value-store-record,
abort-actor-run, scrapers_lat--sec-edgar-filings-scraper

That last entry, scrapers_lat--sec-edgar-filings-scraper, is our filings-research tool. Claude now knows it exists, what it does (from the Actor's README), and what inputs it takes (from the input schema the server passes along).

Step 4: Ask Claude for a filing

Now the payoff. In a normal chat, ask a question that requires ground truth:

"What is Apple's most recent 10-K filing? Give me the filing date, the period it covers, and the accession number."

Claude recognizes it cannot answer this reliably from memory, selects the EDGAR tool, and fills in the input from your question. Under the hood the client sends a tools/call with the Actor's parameters:

{
  "name": "scrapers_lat--sec-edgar-filings-scraper",
  "arguments": {
    "tickers": ["AAPL"],
    "formTypes": ["10-K"],
    "withDetails": true
  }
}

The Apify MCP server starts the Actor, waits for it to finish, and returns the dataset. Here is the real run metadata it produced:

{
  "runId": "rqKgigcewLL3usc1q",
  "actorName": "scrapers_lat/sec-edgar-filings-scraper",
  "status": "SUCCEEDED"
}

A live pull against EDGAR, not the model's memory.

Step 5: Read the real output

The dataset the tool returns is structured filing data. This is an actual record from the run (trimmed to the fields that matter for a company one-pager):

{
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "cik": "0000320193",
  "ein": "94-2404110",
  "stateOfIncorporation": "CA",
  "filerCategory": "Large accelerated filer",
  "fiscalYearEnd": "0926",
  "businessAddress": "ONE APPLE PARK WAY, CUPERTINO, CA 95014",
  "phone": "[phone]",
  "formerNames": [
    { "name": "APPLE COMPUTER INC", "from": "1994-01-26", "to": "2007-01-04" }
  ],
  "latestFiling": {
    "form": "10-K",
    "filingDate": "2025-10-31",
    "reportDate": "2025-09-27",
    "accessionNumber": "0000320193-25-000079",
    "primaryDocument": "aapl-20250927.htm"
  }
}

Claude reads that and answers in plain language: Apple Inc.'s most recent 10-K was filed on 2025-10-31, it covers the fiscal year ending 2025-09-27, and its accession number is 0000320193-25-000079. The model can add the supporting context from the same record: CIK 0000320193, EIN 94-2404110, incorporated in California, a large accelerated filer with a fiscal year end of September 26, headquartered at One Apple Park Way in Cupertino, and formerly named "APPLE COMPUTER INC" until 2007. Every one of those facts is traceable to an official EDGAR record, not the model's memory.

Why the accession number matters: it is the primary key of a filing on EDGAR. With 0000320193-25-000079 and the primary document aapl-20250927.htm, an analyst can jump straight to the exact document the agent used, rather than trusting a paraphrase. That is the difference between a citation and a claim.

A real use case: an equity-research one-pager agent

Put this in context. An equity or credit analyst is building a company one-pager and needs, before writing a word, to confirm the fundamentals: the name and CIK the company files under, its fiscal calendar, and the exact latest annual report on file. Getting the wrong fiscal period or a stale filing into a memo is the kind of error that survives all the way to a client deck.

Without a tool, the analyst opens the EDGAR full-text search, types the ticker, clicks into the filing index, and copies the filing date, period, and accession number by hand, once per company. With the tool wired into Claude, the analyst pastes a ticker into the chat and asks the agent for the latest 10-K, the period it covers, and the accession number. Claude calls the Actor, reads back the filing metadata, and then keeps going in the same conversation: it can summarize the risk factors from that specific filing, note the fiscal year end so the comparison window is right, and cite the accession number so every downstream reader can verify it. Ask "and pull the previous year's 10-K too" and the agent runs the tool again for the earlier period. The mechanical fetch disappears; the analysis stays with the human.

This is the shape of every good agent tool: it removes the mechanical fetch, not the decision.

Going further: chain a second tool

Filings research rarely stops at "which document did they file." The same MCP connection can expose more Actors by extending the tools parameter:

https://mcp.apify.com?tools=scrapers_lat/sec-edgar-filings-scraper,scrapers_lat/sec-form4-insider-trades-scraper

Now the agent can pull a company's 10-K, 10-Q, and 8-K filings and pull the same company's insider transactions (SEC Form 4) in the same conversation, then combine both into one briefing: what the company disclosed, and what its officers and directors were buying or selling around those disclosures. Because each Actor is a separate tool, the agent picks the right one for each step on its own.

🏹 Troubleshooting: if the tool does not appear in Claude, the two usual causes are a missing or misspelled Actor handle in the tools parameter (it must be the exact username/actor-name from the Store URL) and a config that was edited while Claude was running. Fix the handle, save, and fully restart the client.

📌 Note: each tool call is a real Actor run billed to your Apify account (this Actor is pay-per-result). For an interactive one-pager the cost is a fraction of a cent; if you plan to refresh filings for a whole watchlist on a schedule, run the Actor directly through the Apify API or a scheduled task instead of one call per chat message.

Wrapping up

You now have an AI agent that can pull a U.S. company's real SEC filings, on demand, mid-conversation, with the accession number, filing date, and reporting period a research or credit analyst actually needs to cite. The pattern is reusable: pick an Actor that returns authoritative structured data, expose it through the Apify MCP server with the tools parameter, and let the agent decide when to call it.

To take it further:

• Query several tickers at once, or add 10-Q and 8-K to formTypes, to build a quarterly and event-driven filing feed for a whole coverage list.
• Add the Form 4 insider-trades Actor, or other financial-filing Actors, to build a multi-step diligence agent.
• Read the Apify MCP server docs for OAuth setup, resource reads, and the search-actors / call-actor tools that let an agent discover Actors it was not preconfigured with.

The Actor used in this guide: SEC EDGAR 10-K, 10-Q & 8-K Filings Scraper.