# SEC EDGAR Scraper: Financials, 10-K/8-K Filings, Insider Trades (`locaihost/sec-edgar`) Actor

Official SEC data for any US-listed company by ticker: quarterly and annual revenue, net income, EPS, assets, debt and cash flow from XBRL; 10-K/10-Q/8-K filings with 8-K event types; Form 4 insider buys and sells. Public-domain, normalised, new-only mode.

- **URL**: https://apify.com/locaihost/sec-edgar.md
- **Developed by:** [locaihost data](https://apify.com/locaihost) (community)
- **Categories:** AI, Developer tools, MCP servers
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.10 / 1,000 records

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 Scraper: Financials, 10-K/8-K Filings, Insider Trades

Get **official financial data for any US-listed company** straight from the SEC, normalised into clean rows. Enter tickers like `AAPL`, `MSFT` or `JPM` and get:

| Mode | What you get | Source |
|---|---|---|
| 📊 **Fundamentals** | Revenue, net income, operating income, EPS, assets, liabilities, equity, cash, operating cash flow, CapEx, free cash flow, long-term debt and shares outstanding, **per quarter and per fiscal year** | XBRL financial statements in 10-K / 10-Q filings |
| 📄 **Filings** | 10-K, 10-Q, 8-K, proxy, S-1… with **8-K events in plain English** ("2.02 Results of Operations", "5.02 Departure/Election of Directors…") and direct document links | EDGAR filing index |
| 👤 **Insider trades** | Form 4 buys, sells, option exercises and gifts by officers, directors and 10% owners: insider role, shares, price, value, holdings after, 10b5-1 plan flag | Form 4 XML |

![Real fundamentals rows from this Actor's output: NVIDIA and Apple revenue, net income, diluted EPS and free cash flow by fiscal period](https://locaihost.org/img/readme/sec-edgar.png)

### Who is it for?

- **Investors and analysts.** Build a quarterly revenue and margin history, screen for insider buying, or track earnings 8-Ks across a watchlist, in a spreadsheet instead of clicking through EDGAR.
- **Fintech and data builders.** A dependable fundamentals and insider feed for dashboards, screeners, newsletters and backtests, without a market-data licence.
- **AI agents and LLM apps.** Structured, sourced numbers (every row links to the SEC filing) that an agent can cite instead of guessing.
- **Compliance, IR and journalists.** Daily alerts for new 8-Ks or insider sales at the companies you cover.

### Why this one

- **Official SEC data, legal to reuse.** EDGAR content is US government work in the public domain. There's no Yahoo Finance scraping and no terms-of-service grey zone.
- **Doesn't break.** It reads the SEC's own JSON and XML APIs, not web pages, so a site redesign can't take it down. Runs are fast: about 20 seconds for 10 companies with all three modes.
- **Normalised the hard way.** Companies switch XBRL tags over the years, and later filings restate earlier numbers. This Actor handles both:
  - It tries several tags per metric (e.g. `Revenues` → `RevenueFromContractWithCustomerExcludingAssessedTax` → `SalesRevenueNet`) and records which one it used.
  - It keeps the **latest restated value** (e.g. EPS adjusted for stock splits) and flags it.
  - It separates true 3-month quarters from year-to-date figures.
  - It computes quarterly cash flow and fiscal Q4 where the company only reports cumulative numbers.
- **One row per company and period.** Columns, not a pile of raw XBRL facts.
- **New-only mode** for schedules. Each saved task remembers what it already returned, so a daily run gives you only the new filings, trades and periods.

### How to use

1. Enter your **companies**: tickers (`AAPL`, `BRK.B`), CIK numbers (`320193`) or names (`Coca-Cola`).
2. Pick the **modes** you want, and for filings the **form types** and **date range**.
3. Run it. Open the **Fundamentals**, **Filings** or **Insider trades** tab in the output, or export to CSV, Excel or JSON.
4. For alerts, **save it as a task**, turn on **Only new since last run** and add a daily schedule plus an integration (Slack, email, Google Sheets, Zapier, Make, webhook).

#### Example input

```json
{
  "companies": ["AAPL", "MSFT", "NVDA", "JPM"],
  "modes": ["fundamentals", "filings", "insiderTrades"],
  "periods": "both",
  "lastNPeriods": 8,
  "formTypes": ["10-K", "10-Q", "8-K"],
  "sinceDate": "90 days",
  "onlyNew": false
}
```

#### Example output — fundamentals (Apple FY2025, real data)

```json
{
  "recordType": "fundamentals",
  "cik": "0000320193",
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "periodType": "annual",
  "fy": 2025,
  "fp": "FY",
  "periodStart": "2024-09-29",
  "periodEnd": "2025-09-27",
  "form": "10-K",
  "filed": "2025-10-31",
  "accn": "0000320193-25-000079",
  "currency": "USD",
  "revenue": 416161000000,
  "netIncome": 112010000000,
  "operatingIncome": 133050000000,
  "epsBasic": 7.49,
  "epsDiluted": 7.46,
  "totalAssets": 359241000000,
  "totalLiabilities": 285508000000,
  "stockholdersEquity": 73733000000,
  "cashAndEquivalents": 35934000000,
  "operatingCashFlow": 111482000000,
  "capitalExpenditures": 12715000000,
  "freeCashFlow": 98767000000,
  "longTermDebt": 90678000000,
  "sharesOutstanding": 14776353000,
  "derivedMetrics": [],
  "restatedMetrics": [],
  "concepts": { "revenue": "RevenueFromContractWithCustomerExcludingAssessedTax", "netIncome": "NetIncomeLoss", "…": "…" },
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/0000320193-25-000079-index.htm"
}
```

#### Example output — 8-K filing

```json
{
  "recordType": "filing",
  "ticker": "NVDA",
  "companyName": "NVIDIA CORP",
  "form": "8-K",
  "filingDate": "2026-08-26",
  "items": ["2.02", "9.01"],
  "itemDescriptions": ["Results of Operations and Financial Condition", "Financial Statements and Exhibits"],
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/1045810/000104581026000073/nvda-20260826.htm",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1045810/000104581026000073/0001045810-26-000073-index.htm"
}
```

#### Example output — insider trade

```json
{
  "recordType": "insiderTrade",
  "ticker": "AAPL",
  "insiderName": null,
  "insiderType": "individual",
  "insiderRole": "Officer (SVP, GC and Government Affairs)",
  "transactionDate": "2026-10-06",
  "transactionCode": "S",
  "transactionLabel": "Open-market or private sale",
  "acquiredDisposed": "D",
  "shares": 2399,
  "pricePerShare": 332.01,
  "value": 796491.99,
  "sharesOwnedAfter": 39593,
  "directOrIndirect": "D",
  "is10b51Plan": true
}
```

### Output fields

Every record has `recordType` (`fundamentals`, `filing` or `insiderTrade`), `cik`, `ticker` and `companyName`, plus a `filingUrl` back to the SEC.

**Fundamentals**

| Field | Meaning |
|---|---|
| `periodType`, `fy`, `fp` | `annual` (fp `FY`) or `quarterly` (`Q1`–`Q4`); fiscal year as the company reports it |
| `periodStart`, `periodEnd` | The period's own dates |
| `form`, `filed`, `accn` | The 10-K/10-Q that first reported the period |
| `revenue`, `netIncome`, `operatingIncome` | For the period: 3 months for quarters, 12 months for years |
| `epsBasic`, `epsDiluted` | Earnings per share, as reported (split-adjusted if a later filing recast them) |
| `totalAssets`, `totalLiabilities`, `stockholdersEquity`, `cashAndEquivalents`, `longTermDebt` | Balance sheet at `periodEnd` |
| `operatingCashFlow`, `capitalExpenditures`, `freeCashFlow` | Cash flow for the period; free cash flow = operating cash flow − CapEx |
| `sharesOutstanding` | Shares outstanding from the filing's cover page, as of that date. Not adjusted for later stock splits, unlike EPS |
| `derivedMetrics` | Metrics computed by subtraction rather than read directly (see below) |
| `restatedMetrics` | Metrics where a later filing changed the originally reported number; the later number is used |
| `concepts` | The XBRL tag each metric came from, for auditing |

**Filings:** `form`, `filingDate`, `reportDate`, `acceptedAt`, `accessionNumber`, `items` (8-K item codes), `itemDescriptions`, `description`, `documentUrl` (main document), `filingUrl` (filing index).

**Insider trades:** `insiderRole` (e.g. "Officer (CEO)", "Director", "10% Owner"), `insiderType` (individual / entity), `insiderName` + `insiderCik` **for organisations only**, `isDirector`, `isOfficer`, `isTenPercentOwner`, `officerTitle`, `transactionDate`, `transactionCode` + `transactionLabel` (P purchase, S sale, A award, M option exercise, F tax withholding, G gift…), `acquiredDisposed` (A/D), `shares`, `pricePerShare`, `value` (shares × price), `sharesOwnedAfter`, `directOrIndirect` (D/I), `ownershipNature`, `is10b51Plan`, `filingDate`, `accessionNumber`.

### Pricing

**Pay per result.** You pay per record returned: one fundamentals period, one filing or one insider transaction. Looking up companies and fetching data is free, and a new-only run that finds nothing new costs almost nothing (Apify's $0.00005 run-start fee).

| Apify plan | Price per 1,000 records |
|---|---|
| Free and Starter | **$2.00** |
| Scale | $1.50 |
| Business and above | $1.10 |

**Worked examples.**

- Ten companies, fundamentals only, the default last 8 years plus 8 quarters: up to 160 records = **$0.32** on Starter.
- A watchlist of 50 companies on a daily schedule with *Only new* on, finding 30 new filings and insider trades a day: 30 × $0.002 = **$0.06 a day**, under $2 a month.

**Free Apify plan:** each run returns up to **100 records**. Any paid Apify plan removes the cap.

### Use with AI agents (MCP)

Use this Actor as a tool in Claude, Cursor, VS Code or any MCP client through the [Apify MCP server](https://mcp.apify.com). Agents find it by searching for "SEC filings" or "insider trades". Every number comes with a `filingUrl`, so the agent can cite the SEC instead of guessing.

1. Add the server. In Claude Code: `claude mcp add apify https://mcp.apify.com/ -t http`. In Cursor or Claude Desktop, add `https://mcp.apify.com` as a remote MCP server. Sign in with your Apify account when asked, or send your API token as `Authorization: Bearer <APIFY_TOKEN>`.
2. To expose only this Actor as a tool, use `https://mcp.apify.com/?tools=locaihost/sec-edgar`.
3. Ask in plain language, for example:

> Compare NVIDIA's and Apple's revenue, net income and free cash flow for the last four quarters, using SEC filings. Cite the filing for each number.

The minimal input an agent should send:

```json
{
  "companies": ["NVDA", "AAPL"],
  "modes": ["fundamentals"],
  "periods": "quarterly",
  "lastNPeriods": 4
}
```

For insider activity, send `"modes": ["insiderTrades"]` with `"sinceDate": "30 days"`. Ask for only the modes you need: each mode's rows are charged.

### Integrations

Call it from any language with the Apify API. This request waits for the run and returns the records as JSON (synchronous runs time out after 5 minutes; use the async run endpoint for long watchlists):

```bash
curl -X POST "https://api.apify.com/v2/acts/locaihost~sec-edgar/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["AAPL", "MSFT"], "modes": ["fundamentals"], "periods": "annual", "lastNPeriods": 5}'
```

Python, with `pip install apify-client`:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("locaihost/sec-edgar").call(run_input={
    "companies": ["AAPL", "MSFT", "NVDA"],
    "modes": ["insiderTrades"],
    "sinceDate": "30 days",
})
for t in client.dataset(run["defaultDatasetId"]).iterate_items():
    if t["transactionCode"] in ("P", "S"):  # open-market buys and sells only
        print(t["ticker"], t["insiderRole"], t["transactionLabel"], t["shares"], t["value"])
```

**Exports:** the three record types share one dataset. In the Console, open **Export** and pick the **Fundamentals**, **Filings** or **Insider trades** view, so your CSV or Excel file has only that type's columns.

**Schedules:** save a watchlist as a task with *Only new* on and add a daily schedule in Apify Console → Schedules for new-8-K or insider-sale alerts.

**Where the results go:** Apify's built-in integrations send each run's dataset to Slack, email, Google Sheets, Zapier, Make, n8n (the Apify node) or any webhook.

### FAQ

**How fresh is the data?**
Every run reads EDGAR live. A new filing shows up as soon as EDGAR lists it, and a scheduled run with *Only new* returns just the ones you haven't had.

**Is this legal to use and resell?**
The data comes only from the SEC's official EDGAR JSON and XML endpoints. EDGAR content is US government work in the public domain. The Actor identifies itself to the SEC and stays under its fair-access rate limit.

**Does it return personal data?**
Insider trades identify insiders by **role** (CEO, director, 10% owner), not by name. Individuals' names, CIKs, addresses and filing footnotes are never output. Organisations that file as insiders (funds, holding companies) are named.

**Why is `value` 0 on some insider trades?**
Awards, option exercises, tax withholding and gifts (codes A, M, F, G) are often reported at a price of 0. To total insider buying or selling, keep only `transactionCode` `P` (purchase) and `S` (sale).

**Why don't assets equal liabilities plus equity?**
`stockholdersEquity` is the parent company's equity. It excludes non-controlling interests, so for companies that have them (Realty Income, for example) the two sides differ.

**Why is a metric `null`?**
The company didn't use a standard US-GAAP tag for it. Banks, for example, report no operating income. The `concepts` field shows which tag each number came from.

**How many companies can I look up per run?**
Up to 500. Expect about 1 second per company, plus about 1 second for every 8 Form 4 filings.

### Troubleshooting

| What you see | What it means and what to do |
|---|---|
| `Done: 0 new records for 3 companies.` | *Only new* is on and nothing new was filed since the last run. Set `onlyNew: false` to get everything again. |
| `Done: … , 2 not found (see SUMMARY)` | Those inputs didn't match an EDGAR company. Use the ticker (`BRK.B`) or the CIK number (`1067983`). |
| `No companies to look up — not found on EDGAR: …` | No input matched. Check the spelling, or use tickers or CIKs instead of names. |
| Run failed: `Pick at least one mode: …` | `modes` was empty. Add `fundamentals`, `filings` or `insiderTrades`. |
| `(free-plan cap of 100 reached)` | The free plan's per-run cap. Lower `lastNPeriods`, pick fewer modes, or use any paid Apify plan. |
| Run failed: `No data fetched: all N companies failed — see the SUMMARY record.` | EDGAR didn't answer for any company, usually a short SEC outage. Try again later. |
| Fundamentals are empty for a company | It's a fund, a trust or a foreign filer reporting under IFRS (20-F/40-F). Filings and insider trades still work. |

### Good to know

- **As-reported data.** Numbers are what companies tagged in their XBRL filings, not analyst-adjusted figures. If a company doesn't tag a metric with a standard US-GAAP tag, the value is `null`. Examples: banks have no "operating income"; some companies use their own custom tag for CapEx. The `concepts` field shows exactly which tag each number came from.
- **Fiscal Q4** is not filed separately (there is no Q4 10-Q). With *Derive fiscal Q4* on, Q4 revenue, income and cash flow = full year − first nine months. Quarterly cash flow for Q2/Q3 is derived the same way from year-to-date figures. Q4 EPS is left empty because EPS does not add up across quarters. Derived values are listed in `derivedMetrics`.
- **Coverage.** XBRL financials start around 2009–2011, depending on company size. Funds, trusts and foreign companies that report under IFRS (20-F/40-F) have no US-GAAP fundamentals; their filings and insider trades still work.
- **Corporate reorganisations.** If a company moved to a new holding company, its ticker points to the new CIK and older history sits under the old CIK. Add the old CIK number as an extra company to get it.
- **Insider trades** cover Form 4 non-derivative transactions (common stock bought, sold, awarded, exercised or gifted). Option grants in the derivative table are not included. Form 4s that a company files as an *owner* of another company's shares are skipped. Insider names and roles are part of these mandatory public filings. Addresses are never collected.
- **SEC fair-access policy.** The Actor identifies itself to the SEC and stays under 8 requests per second, below the SEC's limit of 10. Large lists of companies take proportionally longer. Expect about 1 second per company, plus about 1 second for every 8 Form 4 filings.
- **New-only memory** is per saved task and settings. Changing companies, modes, form types or periods starts a fresh memory. A fundamentals period is returned again if a later filing restates its numbers.
- **Not investment advice.** The data comes from the SEC's public filings as published.

### Feedback

Missing a metric or a form type you need? Open an issue on the **Issues** tab. Requests are welcome.

#### Privacy

Insider-trade rows identify insiders by **role** (CEO, CFO, director, 10% owner), not by name. Individuals' names, CIKs and filing footnotes are never output. Organisations that file as insiders (funds, holding companies) are named, because that is business data.

# Actor input Schema

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

One per line: a US ticker (AAPL, BRK.B), an SEC CIK number (320193) or a company name (Microsoft). Any company that files with the SEC. Up to 500.

## `modes` (type: `array`):

Fundamentals = income statement, balance sheet and cash-flow figures per quarter/year. Filings = list of 10-K, 10-Q, 8-K… with 8-K event types. Insider trades = Form 4 buys and sells by officers, directors and 10% owners.

## `periods` (type: `string`):

Annual (fiscal years from 10-K), quarterly (fiscal quarters) or both.

## `lastNPeriods` (type: `integer`):

Most recent N years and/or N quarters per company. 0 = full history (back to ~2009).

## `deriveQ4` (type: `boolean`):

Companies file no 10-Q for Q4. When on, Q4 revenue, income and cash flow are computed as full year minus 9 months (EPS is left empty: it does not add up across quarters).

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

Filings mode only. e.g. 10-K, 10-Q, 8-K, DEF 14A, S-1, SC 13D. Amendments (/A) are included. Leave empty for every form.

## `sinceDate` (type: `string`):

Filings and insider trades filed on or after this date. YYYY-MM-DD, or a span like "30 days", "6 months", "2 years". Empty = last 90 days.

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

Newest filings first. 0 = no limit.

## `maxInsiderFilingsPerCompany` (type: `integer`):

Newest first. One Form 4 can hold several trades. 0 = no limit (busy companies file hundreds a year).

## `onlyNew` (type: `boolean`):

Skip filings, trades and periods this saved configuration already returned (a restated period comes back). Ideal for daily schedules: you pay only for what is new.

## `maxResults` (type: `integer`):

Stop after this many records in total. 0 = no limit.

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "NVDA"
  ],
  "modes": [
    "fundamentals",
    "filings",
    "insiderTrades"
  ],
  "periods": "both",
  "lastNPeriods": 8,
  "deriveQ4": true,
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "sinceDate": "90 days",
  "maxFilingsPerCompany": 100,
  "maxInsiderFilingsPerCompany": 50,
  "onlyNew": false,
  "maxResults": 0
}
```

# Actor output Schema

## `overview` (type: `string`):

Every record with its type, company and date.

## `fundamentals` (type: `string`):

One row per company and fiscal period: revenue, net income, EPS, balance sheet, cash flow.

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

10-K, 10-Q, 8-K… with 8-K event types and document links.

## `insiderTrades` (type: `string`):

Form 4 transactions: insider, role, code, shares, price, value.

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

Per company: resolved CIK, counts per mode, notes and errors.

# 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",
        "MSFT",
        "NVDA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("locaihost/sec-edgar").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",
        "MSFT",
        "NVDA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("locaihost/sec-edgar").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",
    "MSFT",
    "NVDA"
  ]
}' |
apify call locaihost/sec-edgar --silent --output-dataset

```

## MCP server setup

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

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/x0IJH5QQzRUjoNkye/builds/Eee07fEtAphduB1km/openapi.json