# SEC EDGAR Filings Scraper by Ticker or CIK (`gubidonius/sec-filings-scraper`) Actor

Every SEC filing a company has made, from EDGAR, in one flat table. Give it a ticker, a CIK or a company name. Filter by form type and date, or watch for new filings on a schedule. No key and no login.

- **URL**: https://apify.com/gubidonius/sec-filings-scraper.md
- **Developed by:** [Gregory Bolshakov](https://apify.com/gubidonius) (community)
- **Categories:** Business, MCP servers, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## SEC EDGAR Filings Scraper

Give it a ticker. Get back every filing that company has made, in one flat table.

### What it does

EDGAR holds every document a public US company files, and it is completely open. The
awkward parts are finding the company and reading the response, and this handles both.

You can name a company three ways and they all work:

```
AAPL              a ticker
320193            a CIK number
Apple Inc.        the exact registered name
```

Anything it cannot resolve is reported by name in the run summary and skipped. It is never
guessed at, because the wrong company is worse than no company.

### The 1,000 filing edge, which is the thing to know

The SEC returns the newest 1,000 filings in one response and keeps everything older in
separate files. A tool that reads the first response and stops gives you a plausible 1,000
rows and quietly loses the rest.

By default this Actor does the same fast thing, and then tells you: the run summary carries
`shardsSkipped` per company, so you always know whether you have the whole history. Turn on
**Read the whole history** and it fetches those files too.

Apple has 1,000 recent filings and 1 older file. Most companies have none.

### Filtering

Form type and date are applied before the per company cap, so asking for 20 8-Ks gives you
the newest 20 8-Ks rather than however many 8-Ks happen to sit inside the newest 20 filings.

Common forms: `10-K` annual report, `10-Q` quarterly, `8-K` material event, `4` insider
trade, `D` funding round, `13F-HR` institutional holdings, `S-1` IPO registration.

### Watching for new filings

Turn on **Only new since the last run** and each run returns only filings that were not
there before, marked `isNew`. The first run on a company records a baseline and returns
everything with `isNew` empty, because nothing is new the first time you look.

If a company's request fails, its previous list is kept and nothing is reported for it. A
filing that never existed is worse than a filing you get a day late.

### Output

One row per filing:

`id` the accession number, `cik`, `company`, `ticker`, `form`, `filingDate`, `reportDate`,
`acceptedAt`, `items`, `fileNumber`, `sizeBytes`, `isXBRL`, `primaryDocument`, `title`,
`url`, `filingIndexUrl`.

`url` points at the document itself and `filingIndexUrl` at the folder listing every
attachment in that filing. Both were checked live.

### Access

EDGAR is free and needs no key. It does ask for a User-Agent that identifies who is calling,
and it throttles anything that does not send one, so this Actor sends a real contact
address on every request.

### Pricing

Pay per event. You are charged for filings you actually get, and the small start charge only
happens once a company returns something.

# Actor input Schema

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

A ticker, a CIK number, or the exact registered name. AAPL, 320193 and Apple Inc. all reach the same company.

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

Keep only these forms. 10-K and 10-Q are the annual and quarterly reports, 8-K is a material event, 4 is an insider trade, D is a funding round. Leave empty for every form.

## `since` (type: `string`):

A date such as 2026-01-01. Filings older than this are dropped before the per company cap is applied.

## `wholeHistory` (type: `boolean`):

The SEC returns the newest 1,000 filings in one response and keeps everything older in separate files. Off, you get the newest 1,000 and the run reports how many older files it skipped. On, it reads them all, which costs one extra request per file.

## `maxFilingsPerCompany` (type: `integer`):

Applied after the form and date filters, so asking for 20 8-Ks gives you the newest 20 8-Ks.

## `onlyNewSinceLastRun` (type: `boolean`):

Returns only filings that were not there last time, marked isNew. The first run on a company records a baseline and returns everything with isNew empty. A company whose request fails is carried forward untouched.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "NVDA",
    "MSFT"
  ],
  "formTypes": [
    "8-K",
    "10-Q"
  ],
  "wholeHistory": false,
  "maxFilingsPerCompany": 100,
  "onlyNewSinceLastRun": false
}
```

# Actor output Schema

## `filings` (type: `string`):

One row per filing, with the form, the dates and a direct link to the document.

## `summary` (type: `string`):

Which companies resolved, how many older files were skipped, and anything that could not be read.

# 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",
        "NVDA",
        "MSFT"
    ],
    "formTypes": [
        "8-K",
        "10-Q"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gubidonius/sec-filings-scraper").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",
        "NVDA",
        "MSFT",
    ],
    "formTypes": [
        "8-K",
        "10-Q",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("gubidonius/sec-filings-scraper").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",
    "NVDA",
    "MSFT"
  ],
  "formTypes": [
    "8-K",
    "10-Q"
  ]
}' |
apify call gubidonius/sec-filings-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/nyaCDmUQXA0DLUSz5/builds/FEm15bBuUgtQAxmdT/openapi.json