# SEC EDGAR API: Filings & XBRL Financials (`axiorasolutions/sec-edgar-api`) Actor

Query SEC EDGAR by ticker or CIK. Returns filing history with form types, dates and document links; XBRL financial facts for chosen concepts; or full-text search hits across all filings. Readable company data for equity research, compliance monitoring and financial datasets. No API key needed.

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

## Pricing

from $1.40 / 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 API — SEC filings, XBRL financials, full-text search

The SEC EDGAR API Actor queries the official SEC EDGAR API by ticker symbol or CIK to return filing history, XBRL financial facts, or full-text search hits. Point it at a company or a phrase and get clean, source-linked records with **no API key and no login**. No unofficial scraper — EDGAR's public JSON API is the source.

### What you get

- `formType`, `filingDate`, `reportDate` and `accessionNumber` for every filing, plus a working `filingUrl`.
- Resolved `cik`, `ticker` and `entityName` backfilled on every row.
- XBRL financial facts with `concept`, `unit`, `value`, `valueNum`, `periodStart`, `periodEnd` and `frame`.
- `isXBRL` / `isInlineXBRL` flags so you can spot machine-readable filings at a glance.
- Full-text search hits with `formType`, `filedDate`, `periodOfReport` and entity metadata.
- A deterministic `recordHash` per row, so two daily runs diff down to just the new filings.

### Quick start

1. Open the Actor and leave **Mode** set to `filings` (or pick `facts` / `search`).
2. Enter one or more tickers or 10-digit CIKs in **Tickers, CIKs, or search terms**.
3. Optionally narrow with `formTypes` and `filedAfter` — "the last four annual reports" is two fields.
4. Click **Start**, then read the **Filings**, **Financial facts** or **Search hits** dataset tab.

A minimal input — the last four 10-K filings for Apple:

```json
{
  "queries": ["AAPL"],
  "mode": "filings",
  "formTypes": ["10-K"],
  "maxFilingsPerCompany": 4
}
```

### Example output

One representative dataset row (a `10-K` filing):

```json
{
  "recordType": "filing",
  "ok": true,
  "errorCode": null,
  "cik": "0000320193",
  "entityName": "Apple Inc.",
  "ticker": "AAPL",
  "accessionNumber": "0000320193-26-000081",
  "formType": "10-K",
  "filingDate": "2026-08-01",
  "reportDate": "2026-06-30",
  "primaryDocument": "aapl-20260630.htm",
  "primaryDocDescription": "10-K",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000081/aapl-20260630.htm",
  "fileSizeBytes": 8421330,
  "isXBRL": true,
  "isInlineXBRL": true,
  "act": "34 Act",
  "fileNumber": "001-36743",
  "recordHash": "c91a4f7be30d8256",
  "scrapedAt": "2026-10-02T12:00:00.000Z"
}
```

### What this SEC EDGAR Actor returns

- 🏢 **Ticker to CIK resolution built in** — pass `AAPL`, `0000320193` or `AAPL` lowercase. The Actor loads EDGAR's official ticker map and resolves it for you. CIKs are zero-padded and stable: **tickers change, CIKs do not**, so CIK is the key your downstream data should use.
- 📄 **Complete filing metadata** — `formType`, `filingDate`, `reportDate`, `accessionNumber`, `primaryDocument`, `primaryDocDescription`, `fileSizeBytes`, `fileNumber`, `act`, plus booleans for **XBRL** and **inline XBRL** so you can tell at a glance which filings carry machine-readable data.
- 🔗 **Working document links** — `filingUrl` points straight at the primary document in the EDGAR archive, built from the accession number so it actually resolves.
- 🔢 **XBRL financial facts with real provenance** — each fact carries `unit`, `value` **and** `valueNum`, plus `periodStart`, `periodEnd`, `frame`, `accessionNumber` and `filingDate`. The SEC's own `conceptLabel` and `conceptDescription` are included, so you never have to guess what `Revenues` means in a given taxonomy.
- 🔍 **Full-text search with paging** — EDGAR returns **10 hits per page**; the Actor pages until it reaches your limit. Filter by form type and by a 1/2/5/10-year window.
- 📅 **Date-aware filtering** — `filedAfter` accepts `2026-01-01` or `1 year`, so "the last four annual reports" is two fields.
- 🔁 **Built for scheduled monitoring** — every row has a deterministic `recordHash`. Diff two daily runs and you get only the new filings, without storing the whole history.
- 🛟 **Honest failures** — an unknown ticker, a company with no XBRL data, or a search with no hits becomes an `ok: false` row with a specific code and an explanation of what was tried.

Running on Apify adds scheduling, webhooks, monitoring, API and SDK access, and one-click export to JSON, CSV, Excel, Google Sheets and 20+ integrations.

### Three modes in detail

#### Filings mode

Give it tickers and form types. `maxFilingsPerCompany: 4` with `formTypes: ["10-K"]` gives you the last four annual reports for each company — the classic equity-research query.

| Input | Effect |
|---|---|
| `formTypes: ["10-K","10-Q"]` | Only annual and quarterly reports |
| `formTypes: ["4"]` | Insider transaction filings |
| `formTypes: ["8-K"]` | Current reports on material events |
| `formTypes: []` | Everything the company has ever filed |

#### Facts mode

Give it tickers and XBRL concepts. Concepts use exact US-GAAP taxonomy names — `Revenues`, `NetIncomeLoss`, `Assets`, `Liabilities`, `StockholdersEquity`, `CashAndCashEquivalentsAtCarryingValue`, `OperatingIncomeLoss`, `EarningsPerShareBasic`. Prefix with `dei:` for disclosure concepts, for example `dei:EntityPublicFloat`.

**Facts mode returns history, not just the latest quarter** — every period the company has reported for that concept. Ten years of annual revenue for one ticker is a few hundred rows. Use `unitsFilter: "USD"` to exclude share counts and per-share values, and `frame` to compare the same calendar period across companies.

#### Search mode

Give it phrases. `"generative AI"`, `"material weakness"`, `"going concern"`, `"climate risk"`. Limit to form types and a date range. This is the fastest way to find which companies are disclosing something specific — a genuinely useful screen for research and for competitive intelligence.

### How to use it

1. Pick a **Mode**.
2. Put tickers, CIKs or search terms in **Tickers, CIKs, or search terms**.
3. Fill in that mode's options — form types, concepts, or search form types and date range.
4. Set **Max records for the whole run** to bound the dataset.
5. Click **Start**, then use the **Filings**, **Financial facts** or **Search hits** dataset tab.

### How much does it cost to query SEC EDGAR?

Pricing is **pay per event** with exactly one event:

| Event | What triggers it | Billed |
|---|---|---|
| Record | One filing, one financial fact, or one search hit written to the dataset | per record |
| Actor start | Once per run, platform fee | per run |

**One event covers all three modes**, so you can switch modes without relearning the bill. Queries that return nothing are **not** billed. Compute, bandwidth and storage are included; there is no separate platform-usage charge on top.

Be aware that **facts mode is the row-heavy one**: a company with a long filing history can return hundreds of values per concept. Set `unitsFilter`, keep the concept list short, and use **Max records for the whole run** to cap it. A single `10-K` filing row costs the same as a single XBRL fact row.

Set **Max cost per run** in the run options for a hard ceiling. Higher Apify plans get progressively lower per-record pricing through Apify Store tier discounts.

Evaluating? Mode **Filings** with `formTypes: ["10-K"]` and one ticker is a handful of rows and gives you the whole shape of the output.

### Example input

Monitoring recent annual and current reports:

```json
{
  "queries": ["AAPL", "MSFT", "0000789019"],
  "mode": "filings",
  "formTypes": ["10-K", "8-K"],
  "maxFilingsPerCompany": 15,
  "filedAfter": "1 year",
  "maxTotal": 200
}
```

Ten years of revenue and net income:

```json
{
  "queries": ["AAPL"],
  "mode": "facts",
  "concepts": ["Revenues", "NetIncomeLoss", "Assets"],
  "unitsFilter": "USD",
  "maxTotal": 500
}
```

Who is disclosing something specific:

```json
{
  "queries": ["\"material weakness\"", "\"going concern\""],
  "mode": "search",
  "searchForms": ["10-K", "10-Q"],
  "searchDateRange": "1y",
  "maxSearchHits": 100
}
```

### Output formats in detail

A filing row:

```json
{
  "recordType": "filing",
  "ok": true,
  "errorCode": null,
  "cik": "0000320193",
  "entityName": "Apple Inc.",
  "ticker": "AAPL",
  "accessionNumber": "0000320193-26-000081",
  "formType": "10-K",
  "filingDate": "2026-08-01",
  "reportDate": "2026-06-30",
  "primaryDocument": "aapl-20260630.htm",
  "primaryDocDescription": "10-K",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000081/aapl-20260630.htm",
  "fileSizeBytes": 8421330,
  "isXBRL": true,
  "isInlineXBRL": true,
  "act": "34 Act",
  "fileNumber": "001-36743",
  "recordHash": "c91a4f7be30d8256",
  "scrapedAt": "2026-10-02T12:00:00.000Z"
}
```

An XBRL fact row:

```json
{
  "recordType": "fact",
  "ok": true,
  "cik": "0000320193",
  "entityName": "Apple Inc.",
  "ticker": "AAPL",
  "concept": "Revenues",
  "conceptLabel": "Revenue from Contract with Customer, Excluding Assessed Tax",
  "taxonomy": "us-gaap",
  "unit": "USD",
  "value": 391035000000,
  "valueNum": 391035000000,
  "periodStart": "2025-09-28",
  "periodEnd": "2026-06-30",
  "formType": "10-K",
  "frame": "CY2026Q2",
  "accessionNumber": "0000320193-26-000081",
  "filingDate": "2026-08-01",
  "recordHash": "4de2b81a97c30f15"
}
```

An unknown ticker:

```json
{
  "recordType": "filing",
  "ok": false,
  "errorCode": "NOT_FOUND",
  "error": {
    "code": "NOT_FOUND",
    "message": "\"NOTATICKER\" is not a known ticker symbol or valid CIK. Check the symbol or supply a 10-digit CIK directly.",
    "hint": "The target does not exist or is not public. Verify the identifier and that the resource is publicly reachable."
  }
}
```

### Use cases

- **Equity research data pipelines** — pull standardised revenue, income and balance-sheet lines for a peer set without a paid financial data vendor.
- **Filing monitoring** — schedule daily, diff on `recordHash`, and alert when a portfolio company files an 8-K.
- **Insider transaction tracking** — `formTypes: ["4"]` gives you Form 4 filings with dates and document links.
- **Disclosure screening** — full-text search for risk phrases across a year of annual reports.
- **LLM and RAG corpora** — `filingUrl` gives stable source documents; `accessionNumber` is a clean key.
- **Academic and compliance research** — reproducible, source-linked datasets straight from the regulator.

### Related Actors by Axiora Solutions

| Actor | Use it for |
|---|---|
| **News & RSS Feed Scraper** | The news coverage around the filings you are tracking |
| **ATS Job Scraper** | Hiring signals for the same public companies |
| **Domain Contact Enricher** | Technology and contact profiles for the corporates in your list |

### Frequently asked questions

#### Is this an official API?

Yes. It uses `data.sec.gov` and `efts.sec.gov`, the SEC's own public JSON interfaces. It is not screen scraping.

#### Do I need an API key?

No. EDGAR is open. The Actor sends an identifying User-Agent with a contact address, which is what the SEC's fair-access policy asks for, and paces requests to stay well inside their published limits.

#### Why do some companies have no XBRL facts?

XBRL reporting is required for most US domestic filers, but not for every filing type or every foreign private issuer. When there is nothing on file you get an `ok: false` row with `EMPTY_RESULT` and that explanation, rather than an empty dataset you have to debug.

#### Why do I get so many rows in facts mode?

Because XBRL facts are historical. Each concept returns every period the company has reported, across every unit. Two things keep it manageable: **`unitsFilter: "USD"`** to drop share and per-share units, and **Max records for the whole run** as a hard ceiling. Start with one concept and one ticker to see the volume before scaling up.

#### Should I use ticker or CIK in my own database?

**CIK.** Tickers are reassigned when companies are acquired or delisted; CIKs are permanent. Every row carries both, and the Actor resolves either on input.

#### Why is the same concept value listed more than once?

Because companies restate figures, and because the same value can appear in several filings. `accessionNumber`, `filingDate` and `frame` let you pick the authoritative filing for a period. `recordHash` is unique per fact occurrence, so de-duplication is straightforward.

#### Does full-text search cover all history?

EDGAR full-text search covers filings from 2001 onward, and it returns at most 10 hits per page — the Actor pages through automatically. It searches document text, not XBRL values.

#### Can I run this on a schedule?

Yes. Daily `8-K` monitoring for a watchlist is the most common pattern: set `filedAfter: "2 days"`, deduplicate on `recordHash`.

#### Something looks wrong — how do I report it?

Open the **Issues** tab on this Actor page with the ticker, the mode and the row you got. EDGAR occasionally changes payload shapes and those get fixed fastest with a concrete example.

***

Runnable examples and how-to guides for these Actors: [github.com/batow133/axiora-apify-actors](https://github.com/batow133/axiora-apify-actors)

# Actor input Schema

## `queries` (type: `array`):

What to look up. Mode determines the meaning. For filings and facts: ticker symbols (AAPL, MSFT) or 10-digit CIKs (0000320193). For full-text search: keyword or phrase ("generative AI"). Mix formats freely.

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

filings: submission history for each ticker or CIK, filterable by form type. facts: XBRL financial values for named concepts. search: full-text search across all filings for keywords.

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

Keep only filings of these form types. Common: 10-K, 10-Q, 8-K, 4, DEF 14A, S-1. Leave empty to keep everything. Only used in filings mode.

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

Newest-first. A value of 4 with formTypes=\["10-K"] returns the last four annual reports.

## `filedAfter` (type: `string`):

Keep only filings filed on or after this date. Accepts 2026-01-01 or a relative value such as 1 year.

## `concepts` (type: `array`):

Financial line items to fetch in facts mode. Use the US GAAP taxonomy name exactly: Revenues, NetIncomeLoss, Assets, Liabilities, CashAndCashEquivalentsAtCarryingValue, StockholdersEquity, EarningsPerShareBasic, OperatingIncomeLoss. Taxonomy defaults to us-gaap; prefix with dei: for DEI concepts like EntityPublicFloat.

## `unitsFilter` (type: `string`):

Keep only XBRL fact values denominated in this unit: USD, shares, pure. Leave empty to keep everything.

## `searchForms` (type: `array`):

Limit full-text search results to these form types. Leave empty to search all filings. Only used in search mode.

## `searchDateRange` (type: `string`):

Limit full-text search to filings within this period: 1y, 2y, 5y, or 10y back from today. Leave empty for all time.

## `maxSearchHits` (type: `integer`):

EDGAR full-text search returns at most 10 hits per page. This Actor pages until it reaches your limit or EDGAR has no more results.

## `maxTotal` (type: `integer`):

Hard ceiling across all queries and modes.

## Actor input object example

```json
{
  "queries": [
    "AAPL",
    "0000789019",
    "META",
    "\"series A\""
  ],
  "mode": "filings",
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxFilingsPerCompany": 20,
  "filedAfter": "1 year",
  "concepts": [
    "Revenues",
    "NetIncomeLoss",
    "Assets"
  ],
  "unitsFilter": "USD",
  "searchForms": [
    "10-K",
    "8-K"
  ],
  "maxSearchHits": 50,
  "maxTotal": 2000
}
```

# Actor output Schema

## `records` (type: `string`):

Every record collected, typed by recordType.

## `runSummary` (type: `string`):

Mode, queries resolved, record counts, billing and network totals.

# 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 = {
    "queries": [
        "AAPL",
        "MSFT"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiorasolutions/sec-edgar-api").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 = { "queries": [
        "AAPL",
        "MSFT",
    ] }

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

```

## MCP server setup

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

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/tRG3uGW9UcNmpTwjG/builds/WmOgnaUNYBRr1cTas/openapi.json