# SEC EDGAR Filings Search API & XBRL Company Financials (`lathewright/sec-edgar-filings`) Actor

Returns SEC EDGAR filings (8-K, 10-K, 10-Q, S-1, 13F and more) by full-text search or ticker, plus clean XBRL financial snapshots (revenue, net income, assets, EPS) from the official SEC APIs. No key. Built for AI agents, analysts and automations.

- **URL**: https://apify.com/lathewright/sec-edgar-filings.md
- **Developed by:** [lathewright LLC](https://apify.com/lathewright) (community)
- **Categories:** Business, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 filing founds

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?

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 Filings Search API & XBRL Company Financials

Search the full text of SEC EDGAR filings, list the latest filings for any public company, or pull multi-year XBRL financial snapshots by ticker or CIK, for analysts, investor-relations and compliance teams and AI agents. It costs $0.002 per filing and $0.02 per company financial snapshot, so 100 filings cost $0.20.

Search the full text of every SEC filing, list the latest filings for any public company, or pull a clean multi-year financial snapshot (revenue, net income, assets, cash flow, EPS) straight from the SEC's XBRL data. Uses only the SEC's official, keyless APIs and returns tidy JSON that agents and spreadsheets can use as-is.

Built and maintained by **Lathewright**. Lathewright is operated by AI systems under human ownership. A person reviews and approves everything we publish, send and sell. Pay only for what you get: **$0.002 per filing** and **$0.02 per company financial snapshot**.

### What you can do with it

- **Monitor events**: find every 8-K that mentions a `"cybersecurity incident"`, `"going concern"`, `"material weakness"`, a competitor's name or a product, filed in a date range.
- **Track companies**: get the newest 10-K, 10-Q, 8-K, S-1, 13F or Form 4 filings for a list of tickers, with direct document links.
- **Get the numbers**: revenue, gross profit, operating income, net income, total assets and liabilities, equity, cash, operating cash flow, capex, long-term debt, diluted and basic EPS and shares outstanding for the last N fiscal years and quarters, keyed by the real period end date (no mislabeled comparatives).
- **Feed an agent**: every field is flat, typed and documented, so an LLM can answer "what did NVIDIA report for FY2026?" in one tool call.

### Example tasks

Paste any of these into the Input tab, or send the same JSON through the API. Prices are the per-result prices listed under Pricing.

#### 1. Recent 8-Ks mentioning a cybersecurity incident

```json
{
  "mode": "fullTextSearch",
  "query": "\"cybersecurity incident\"",
  "forms": ["8-K"],
  "dateFrom": "2026-10-01",
  "maxResults": 25
}
```

What comes back: One row per filing with `entityName`, `ticker`, `form`, `filedAt`, `periodOfReport`, `items`, `documentUrl` and `accessionNumber`. Up to 25 rows, at most $0.05.

#### 2. Latest annual and quarterly reports for two companies

```json
{
  "mode": "companyFilings",
  "identifiers": ["AAPL", "NVDA"],
  "forms": ["10-K", "10-Q"],
  "maxResults": 10
}
```

What comes back: The most recent matching filings per company, same filing fields.

#### 3. Five years of financials for Apple

```json
{
  "mode": "companyFinancials",
  "identifiers": ["AAPL"],
  "annualPeriods": 5,
  "quarterlyPeriods": 8
}
```

What comes back: One row with `annual` and `quarterly` XBRL figures. $0.02 per company.

### Modes

| `mode` | What it needs | What you get | Billed as |
|---|---|---|---|
| `fullTextSearch` | `query`, optional `forms`, `dateFrom`, `dateTo`, `identifiers` | One row per matching filing with company, form, date, 8-K item codes, document URL | `filing-result` |
| `companyFilings` | `identifiers` (tickers or CIKs), optional `forms`, dates, `maxResults` | Latest filings per company with primary document URL | `filing-result` |
| `companyFinancials` | `identifiers`, optional `annualPeriods`, `quarterlyPeriods` | One row per company with `annual[]` and `quarterly[]` metric tables | `company-financials` |

Unknown tickers or filers without XBRL data are returned as error rows (`type: "error"`) and billed at the reduced `lookup-error` rate, so a bad identifier never kills the run.

### Pricing

| Event | Price | Notes |
|---|---|---|
| Filing found (`filing-result`) | $0.002 | Primary event. 50 filings = $0.10 |
| Company financial snapshot (`company-financials`) | $0.02 | Up to 15 fiscal years and 40 quarters per company |
| Failed lookup (`lookup-error`) | $0.0005 | Unknown ticker, no XBRL facts, SEC error |

Plus Apify's standard start fee ($0.00005 per run). No proxies are used, so there are no hidden platform costs. Set a **maximum cost per run** in the Console or API and the Actor stops cleanly at the limit with everything found so far saved.

### Output examples

Filing row:

```json
{
  "type": "filing",
  "entityName": "Astrana Health, Inc.",
  "ticker": "ASTH",
  "cik": "0001083446",
  "form": "8-K",
  "filedAt": "2026-09-23",
  "periodOfReport": "2026-09-22",
  "accessionNumber": "0001104659-26-109813",
  "items": ["1.05"],
  "state": "CA",
  "sic": "8742",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/1083446/000110465926109813/asth-20260922x8k.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1083446/000110465926109813/0001104659-26-109813-index.htm",
  "source": "efts.sec.gov full-text search"
}
```

Financial snapshot row (abridged):

```json
{
  "type": "financials",
  "entityName": "Apple Inc.",
  "ticker": "AAPL",
  "cik": "0000320193",
  "latestFiscalYear": 2025,
  "latestRevenue": 416161000000,
  "latestNetIncome": 112010000000,
  "latestEpsDiluted": 7.46,
  "annual": [
    { "fiscalYear": 2025, "periodEnd": "2025-09-27", "revenue": 416161000000, "netIncome": 112010000000, "totalAssets": 359241000000, "epsDiluted": 7.46, "sharesOutstanding": 14773260000 }
  ],
  "quarterly": [
    { "calendarQuarter": "2026-Q2", "periodEnd": "2026-06-27", "revenue": 109417000000, "netIncome": 29789000000, "epsDiluted": 2.02 }
  ]
}
```

### How to use it

- **Apify Console**: fill in the form, press Start, download JSON, CSV or Excel from the Output tab.
- **API**: `POST https://api.apify.com/v2/acts/lathewright~sec-edgar-filings/run-sync-get-dataset-items?token=<token>` with the input JSON as the body.
- **n8n, Make, Zapier**: use the Apify node/module, pick this Actor, paste the input JSON. Schedule it daily to get an alert feed of new filings.

### Use from an AI agent (MCP)

Add this Actor as a tool in Claude, Cursor, VS Code or any MCP client with `https://mcp.apify.com/?tools=lathewright/sec-edgar-filings`. The Actor description is the tool description, and the input fields above are the tool parameters. Example prompts: "Search EDGAR for 8-K filings mentioning data breach this month", "Give me five years of revenue and net income for NVDA".

### Data source, fair use and limits

- Data comes from the SEC's public EDGAR full-text search (`efts.sec.gov`), submissions API and XBRL company-facts API (`data.sec.gov`). These are official, keyless services; the Actor declares a User-Agent with a contact address and stays far below the SEC's 10 requests per second limit.
- Full-text search covers filings from 2001 onwards; XBRL financials exist from roughly 2009 and only for filers that tag their statements (not for most funds, and some foreign private issuers).
- Revenue and net income use the most common US GAAP tags. Banks, insurers and companies using custom tags may show gaps; the `annual[]` rows still carry whatever was tagged.
- No personal data is collected. Public company filings are public records.

### FAQ

**Can I get the filing text?** This Actor returns metadata and direct document links. Pair it with Apify's Website Content Crawler or any HTML-to-text Actor to read the filing body.

**How fresh is it?** Full-text search indexes filings within minutes of acceptance. Financials appear once the XBRL exhibits are processed (usually the filing day).

**Does it work for 13F holdings or Form 4 insider trades?** You can find and link those filings with `fullTextSearch` or `companyFilings`. Parsing the holdings tables is a separate Actor.

# Actor input Schema

## `mode` (type: `string`):

What to fetch. `fullTextSearch` searches filing text (needs `query`). `companyFilings` lists recent filings for `identifiers`. `companyFinancials` returns key XBRL financial metrics for `identifiers`.

## `query` (type: `string`):

Full-text query for `fullTextSearch`. Use quotes for exact phrases, e.g. `"cybersecurity incident"` or `"going concern" AND lithium`.

## `forms` (type: `array`):

Limit to these form types, e.g. 8-K, 10-K, 10-Q, S-1, 13F-HR, DEF 14A, 4. Leave empty for all.

## `dateFrom` (type: `string`):

Only filings filed on or after this date. Defaults to 30 days ago for full-text search.

## `dateTo` (type: `string`):

Only filings filed on or before this date. Defaults to today.

## `identifiers` (type: `array`):

Company tickers (AAPL, MSFT) or CIK numbers. Used by `companyFilings` and `companyFinancials`, and as an optional entity filter in `fullTextSearch`.

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

Maximum number of filings (per company for `companyFilings`, total for `fullTextSearch`). Each result is one billable event.

## `annualPeriods` (type: `integer`):

How many fiscal years of annual figures to include in `companyFinancials`.

## `quarterlyPeriods` (type: `integer`):

How many recent quarters to include in `companyFinancials`.

## `compactOutput` (type: `boolean`):

Return only the key fields (smaller, cheaper for AI agents to read).

## Actor input object example

```json
{
  "mode": "fullTextSearch",
  "query": "\"cybersecurity incident\"",
  "forms": [
    "8-K"
  ],
  "maxResults": 10,
  "annualPeriods": 5,
  "quarterlyPeriods": 8,
  "compactOutput": false
}
```

# Actor output Schema

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

Every filing or financial snapshot found, one JSON object per row.

# 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 = {
    "query": "\"cybersecurity incident\"",
    "forms": [
        "8-K"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("lathewright/sec-edgar-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 = {
    "query": "\"cybersecurity incident\"",
    "forms": ["8-K"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("lathewright/sec-edgar-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 '{
  "query": "\\"cybersecurity incident\\"",
  "forms": [
    "8-K"
  ],
  "maxResults": 10
}' |
apify call lathewright/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lathewright/sec-edgar-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/0EnoYW4JvJ3CPwJkA/builds/lSY17fNM5VfocY3Kp/openapi.json