# Get SEC Filings & Company Data from EDGAR by Ticker (`benuelh/sec-edgar-company-filings`) Actor

SEC EDGAR scraper for company lookup: enter tickers or company names, get JSON with CIK, legal name, SIC industry, fiscal year end, HQ, plus recent SEC filings (10-K, 8-K) with links. Filter by form type. No API key or login. $0.01 per company. Works via Apify MCP.

- **URL**: https://apify.com/benuelh/sec-edgar-company-filings.md
- **Developed by:** [Ben Harmon](https://apify.com/benuelh) (community)
- **Categories:** Lead generation, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 company profile returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 📑 SEC EDGAR Company Filings: recent filings and company profiles from tickers or names

This Actor looks up US public companies by ticker or name and returns their company profile plus a list of recent SEC filings (10-K, 10-Q, 8-K and more), each with a plain-English form meaning and a direct document link.
It is built for analysts, investors, researchers, compliance teams and developers who want structured filing data without manual searching.

*✅ Last verified working: 2026-10-22 (automated daily test run)*

### ✨ What you get

- **Company profile**: official name, 10-digit CIK, tickers, exchanges, SIC code and description, state of incorporation, fiscal year end (for example "September 28"), business city and state, entity type.
- **Recent filings**: form type, a readable `formMeaning` (for example "Annual report" for 10-K), filing date, report date, description and a direct document URL.
- **Form filtering**: keep only the form types you care about, such as 10-K and 8-K.
- **Flexible matching**: each input is matched by exact ticker first, then exact company name, then the first company name containing your text.
- **Clean errors**: companies that cannot be found come back as a clear `not found` item, and the run continues.
- Uses public SEC data only. No login or API key is needed.

### Use with AI agents (MCP)

This Actor works with the [Apify MCP server](https://mcp.apify.com), so Claude, ChatGPT, Cursor and other MCP clients can find it with the `search-actors` tool and run it with `call-actor`. To load it directly as a tool, connect to `https://mcp.apify.com?tools=benuelh/sec-edgar-company-filings`.

Smallest working input:

```json
{
  "companies": [
    "AAPL"
  ],
  "maxFilings": 10
}
```

Each result row has: `input`, `name`, `cik`, `tickers`, `exchanges`, `sicCode`, `sicDescription`, `stateOfIncorporation`, `fiscalYearEnd`, `businessCity`, `businessState`, `entityType`, `filingsCount`, `filings` (plus `error`, set only when an item could not be processed).

Price: $0.01 per company profile returned. Charged once per matched company returned with its profile and recent filings. Tickers or names that are not found, and failed requests, are never charged. Agents using Apify agentic payments can run it without an Apify account.

### 🎯 Popular uses

- Monitor new 8-K current reports for a watchlist of tickers.
- Pull the latest annual and quarterly reports for due diligence.
- Track insider transaction forms (Form 4) across several companies.
- Feed filing links into research notes, dashboards or alerts.
- Enrich a company list with SIC industry codes, fiscal year ends and business locations.

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `companies` | array of strings | Yes | 1 to 50 tickers or company names, e.g. `AAPL` or `Microsoft`. |
| `maxFilings` | integer | No | Filings to return per company, 1 to 100. Default 10. |
| `formTypes` | array of strings | No | Form types to keep, e.g. `10-K`, `8-K`. Case-insensitive exact match. Leave empty for all forms. |

Example:

```json
{
  "companies": ["AAPL"],
  "maxFilings": 10
}
```

Example with a form filter:

```json
{
  "companies": ["MSFT", "Tesla"],
  "maxFilings": 5,
  "formTypes": ["10-K", "8-K"]
}
```

### 📦 Output

One dataset item is produced per input company. The example below shows a found company followed by a company that was not found. Values are illustrative.

```json
[
  {
    "input": "AAPL",
    "name": "Apple Inc.",
    "cik": "0000320193",
    "tickers": ["AAPL"],
    "exchanges": ["Nasdaq"],
    "sicCode": "3571",
    "sicDescription": "Electronic Computers",
    "stateOfIncorporation": "CA",
    "fiscalYearEnd": "September 28",
    "businessCity": "Cupertino",
    "businessState": "CA",
    "entityType": "operating",
    "filingsCount": 1,
    "filings": [
      {
        "form": "10-K",
        "formMeaning": "Annual report",
        "filingDate": "2024-11-01",
        "reportDate": "2024-09-28",
        "description": "10-K",
        "url": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm"
      }
    ]
  },
  {
    "input": "Not A Real Company",
    "error": "not found"
  }
]
```

Forms without a built-in label are described as `Other: ` followed by the filing description.

The Actor does not output phone numbers, EINs or person names. Business city and state are the company's registered business address as published by the SEC, which is company data and not personal data.

### 💰 Pricing

**$0.01 per company** that is matched and returned. The number of filings per company does not change the price.

You are never charged for:

- inputs that return `not found`
- inputs that end in an error item (for example an HTTP error from the data source)

### ❓ FAQ

**Do I need an SEC account or API key?**
No. The Actor reads public SEC endpoints and needs no login.

**How are companies matched?**
By exact ticker (case-insensitive), then exact company name, then the first company name that contains your text. Use a ticker for the most predictable result.

**Which filings are returned?**
The company's recent filings as listed by the SEC, newest first, after your form filter is applied, limited to `maxFilings`.

**Are form type filters case-sensitive?**
No. `10-k` and `10-K` behave the same, but the match must be exact, so `10-K` will not match `10-K/A`.

**What happens if the data source is busy?**
Requests that receive a rate-limit or server error are retried twice with backoff. Requests are paced to stay within SEC fair-access limits.

**What if one company fails?**
It is pushed as an item with an `error` field, is not charged, and the run continues with the remaining companies.

# Actor input Schema

## `companies` (type: `array`):

Tickers or company names to look up (1-50), e.g. AAPL or Microsoft.

## `maxFilings` (type: `integer`):

Maximum number of recent filings to return per company (1-100).

## `formTypes` (type: `array`):

Optional list of form types to keep, e.g. 10-K, 8-K (case-insensitive exact match). Leave empty for all forms.

## Actor input object example

```json
{
  "companies": [
    "AAPL"
  ],
  "maxFilings": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items with company details and recent filings, shown in the overview table view.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("benuelh/sec-edgar-company-filings").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "companies": ["AAPL"] }

# Run the Actor and wait for it to finish
run = client.actor("benuelh/sec-edgar-company-filings").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "AAPL"
  ]
}' |
apify call benuelh/sec-edgar-company-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,benuelh/sec-edgar-company-filings"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XcObNuwfQsSgC5p2W/builds/JONAuUlYmNVwjKqNM/openapi.json