# SEC EDGAR API — Filings, XBRL Financials & Full-Text Search (`insight.solutions/sec-edgar-api`) Actor

Query the SEC's official EDGAR APIs from one Actor: resolve any ticker, CIK or company name; list 10-K, 10-Q, 8-K and Form 4 filings by date; pull normalized XBRL income statement, balance sheet and cash flow by period; run full-text search across filings since 2001. No API key.

- **URL**: https://apify.com/insight.solutions/sec-edgar-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Business, Developer tools, News
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.18 / 1,000 filing 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 — Filings, XBRL Financials & Full-Text Search

**Get SEC filings and financials by ticker or CIK, as clean JSON, with no API key.** Give it `AAPL`, `320193` or `Apple Inc.` and get back the company record, the 10-K / 10-Q / 8-K / Form 4 filing history, a normalized income statement, balance sheet and cash flow built from XBRL, or full-text search hits across filing documents.

Every request goes to the SEC's own public JSON APIs — `data.sec.gov`, `www.sec.gov` and `efts.sec.gov` — so the data is EDGAR's, live, and no scraping or login is involved. Filings appear within minutes of acceptance. **From $0.0003 per filing record**, and diagnostic rows are free.

Most SEC Actors cover exactly one slice: Form D only, Form 4 only, financials only. This one covers all four in a single, consistent interface — which is what makes it useful to an agent that does not know in advance what it will need.

### Try it in 30 seconds

The five most recent Apple annual reports:

```json
{
  "mode": "filings",
  "identifiers": ["AAPL"],
  "formTypes": ["10-K"],
  "maxFilingsPerCompany": 5,
  "userAgentContact": "Acme Research data@acme.com"
}
```

**Set `userAgentContact` to your own organisation and a working address.** The SEC requires every automated request to say who is making it and answers HTTP 403 otherwise. The Console example is pre-filled with the publisher's contact so the sample run works out of the box; replace it with yours for real use, so the SEC reaches you, not us, about your traffic. Runs with an empty or placeholder contact stop with an explanatory row and are not charged.

**Output** — one row per filing (or per company, or per statement × fiscal period); the fields you will use most are `cik`, `companyName`, `formType`, `filingDate`, `documentUrl` (full list under *Output reference*). Anything that could not be fetched comes back as a free diagnostic row (`ok: false`, `errorType`, `error`) instead of a charge, and every run ends with one free summary row saying what it did.

```json
{ "ok": true, "cik": "320193", "companyName": "Apple Inc.", "formType": "10-K", "filingDate": "2024-11-01", "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm" }
```

**Price** — $0.30 per 1,000 filing records on the FREE tier (+ $0.0005 per run that returns a row); company records are $0.50 per 1,000, financial periods $0.40 per 1,000, and diagnostic rows are free. Pay-per-event, no API key, no browser, limited permissions — works over the Apify MCP server (`mcp.apify.com`) and with agentic (x402) payments.

**From code** — `client.actor("insight.solutions/sec-edgar-api").call(run_input={…})` with `apify-client`, or `POST https://api.apify.com/v2/acts/insight.solutions~sec-edgar-api/run-sync-get-dataset-items`.

### Four modes: company, filings, XBRL financials, full-text search

| Mode | Give it | Get back | Charged as |
|---|---|---|---|
| `company` | tickers / CIKs / names | One entity record per company: SIC code, exchanges, addresses, fiscal year end, former names | `company-record` |
| `filings` | identifiers + optional form and date filters | One row per filing, with direct links to the primary document and the filing index | `filing-record` |
| `financials` | identifiers | One row per statement per fiscal period, with normalized concepts and source XBRL tags | `financial-period` |
| `fullTextSearch` | a search phrase, optionally scoped to companies, forms and dates | One row per matching filing document, with a highlighted snippet | `filing-record` |

More examples:

```json
{ "mode": "financials", "identifiers": ["MSFT"], "statements": ["income", "cashflow"], "periodType": "annual", "maxPeriods": 4 }
```

```json
{ "mode": "fullTextSearch", "query": "\"material weakness\"", "formTypes": ["10-K"], "filedAfter": "2023-01-01", "maxFilingsPerCompany": 50 }
```

```json
{ "mode": "filings", "identifiers": ["TSLA", "NVDA", "AMD"], "formTypes": ["8-K"], "filedAfter": "2024-01-01", "maxFilingsPerCompany": 200 }
```

### Use cases

- **Pull 10-K and 10-Q financials by ticker** into a model or spreadsheet — revenue, gross profit, operating income, net income, EPS, free cash flow, per fiscal period.
- **Build a filings alert feed** — `filings` mode with `formTypes: ["8-K"]` and `filedAfter` set to your last check, on an Apify Schedule.
- **Search the text of SEC filings** for a phrase — "material weakness", "going concern", a product name — across every filer since 2001, then follow `documentUrl` to the source.
- **Screen companies before a deal or an investment** — `company` mode returns SIC code, exchanges, fiscal year end and former names for a whole ticker list in one run.
- **Ground an LLM or research agent in primary sources** — every row carries `source`, `sourceUrl` and, for financials, the exact XBRL tag behind each number.
- **Track insider and ownership filings** — Form 4 and Form D are just `formTypes` values.

To turn Form D filings into a daily feed of funding rounds, with amounts, industries and states and the press-wire and news announcements matched to them, use [Funding Signals API](https://apify.com/insight.solutions/funding-signals-api).

### How it compares

- **Four modes, one Actor.** Company resolution, filing history, normalized financials and full-text search behind one input schema, instead of four listings that each do one.
- **XBRL that is actually normalized.** US-GAAP tagging is inconsistent between filers and across years. Each field is filled from a documented fallback chain of tags, and `rawConcepts` records exactly which tag, filing and date produced each number — so nothing is hidden and nothing is unauditable.
- **Complete filing history, not a silent truncation.** Large filers keep only their most recent ~1,000 filings in the main submissions file; the rest live in overflow pages. This Actor walks up to five of those per company, skipping any whose date window cannot match, so a request for older filings gets real answers.
- **Any identifier resolves.** `AAPL`, `320193`, `0000320193` and `Apple Inc.` all land on the same company. Multi-class tickers (`GOOG` / `GOOGL`) resolve to one CIK and are returned once, so you are charged once.
- **Charge-on-success, and a named cause.** An identifier that does not resolve, a filter matching no filings, an SEC outage — all produce free diagnostic rows. A run whose input was usable but that returns nothing — a ticker that does not exist, a filter that matches no filings, the SEC refusing or failing us — finishes **SUCCEEDED with zero results**, with a status message that says so and names the cause. Such a run costs nothing, start fee included — and if the SEC refused us, the status says which of its two refusals it hit, its rate threshold or its undeclared-tool check, because those need opposite responses. A run finishes **FAILED** only when the Actor itself hit an error.

### Input reference

| Field | Type | Default | Applies to | Notes |
|---|---|---|---|---|
| `mode` | string | `filings` | all | `company`, `filings`, `financials`, or `fullTextSearch` |
| `identifiers` | array | `["AAPL"]` | all | Tickers, CIKs (padded or not), or company names. Required except in `fullTextSearch`, where it narrows the search |
| `formTypes` | array | all forms | `filings`, `fullTextSearch` | e.g. `["10-K","10-Q","8-K","4","D"]`. Asking for `10-K` also returns `10-K/A`, flagged with `isAmendment` |
| `filedAfter` / `filedBefore` | date | — | `filings`, `fullTextSearch` | Inclusive bounds on filing date, `YYYY-MM-DD` |
| `maxFilingsPerCompany` | integer | `50` | `filings`, `fullTextSearch` | Filings per company, newest first. In `fullTextSearch` it caps total hits. Max 1000 |
| `statements` | array | all three | `financials` | Any of `income`, `balance`, `cashflow`. One row per statement per period |
| `periodType` | string | `annual` | `financials` | `annual`, `quarterly`, or `both` |
| `maxPeriods` | integer | `8` | `financials` | Periods per company, most recent first. With `both`, applies to each separately. Max 40 |
| `query` | string | — | `fullTextSearch` | Required. Wrap a phrase in double quotes for an exact match |
| `includeDocumentUrls` | boolean | `true` | `filings`, `fullTextSearch` | Include links to the primary document and the filing index page |
| `userAgentContact` | string | — | all | **Required in practice.** Your organisation and a working contact address |
| `maxRunSecs` | integer | `240` | all | Wall-clock budget. The Actor stops asking for more data when reached, keeps everything written, and says so. Min 30, max 3600 |

### Output reference

Every row carries `ok`, `source`, `sourceUrl` and `scrapedAt`. Rows where `ok` is `false` are diagnostics and are never charged; `errorType` says which kind of problem it was (`unresolved-identifier`, `no-results`, `not-found`, `invalid-input`, `budget-exhausted`, `time-budget`, or an upstream class: `rate-limited`, `user-agent-rejected`, `forbidden`, `network`, `http`, `parse`, `upstream-shape`).

Every run also ends with **one free summary row**, `rowType: "run-summary"` — never charged, and easy to drop with a single test. It reports `rowsWritten`, `diagnosticRows`, `secRequests`, `elapsedSecs`, whether the time or charge budget stopped the run, and — the reason it exists — `secAccessIssue`, which is `null`, `"rate-limited"` or `"user-agent-rejected"`. Those last two are the only two ways the SEC refuses a client, and they need opposite responses: wait a few minutes, or fix your contact string.

```json
{ "ok": true, "rowType": "run-summary", "mode": "filings", "rowsWritten": 5, "diagnosticRows": 0,
  "secRequests": 2, "secAccessIssue": null, "rateLimitedResponses": 0, "userAgentRejectedResponses": 0,
  "requestsPerSecondCeiling": 8, "elapsedSecs": 0.7, "summary": "5 row(s) written in 0.7s · 2 SEC request(s)" }
```

**`filings`** — `cik`, `companyName`, `accessionNumber`, `formType`, `baseFormType`, `isAmendment`, `filingDate`, `reportDate`, `acceptanceDateTime`, `primaryDocument`, `primaryDocDescription`, `documentUrl`, `filingIndexUrl`, `size`, `isXBRL`, `isInlineXBRL`, `items`.

**`company`** — `cik`, `cikPadded`, `ticker`, `tickers`, `name`, `sic`, `sicDescription`, `entityType`, `exchanges`, `fiscalYearEnd`, `category`, `ein`, `stateOfIncorporation`, `phone`, `businessAddress`, `mailingAddress`, `formerNames`, `matchedOn`, `matchedInputs`.

**`fullTextSearch`** — `accessionNumber`, `cik`, `companyName`, `tickerFromDisplayName`, `formType`, `filingDate`, `periodEnding`, `snippet`, `documentUrl`.

**`financials`** — one row per statement per period:

```json
{
  "ok": true,
  "cik": "320193", "companyName": "Apple Inc.",
  "statement": "income", "periodType": "annual",
  "fiscalYear": 2024, "fiscalPeriod": "FY", "fiscalLabelSource": "sec-fy-fp",
  "periodStart": "2023-10-01", "periodEnd": "2024-09-28", "periodDays": 363,
  "unit": "USD",
  "revenues": 391035000000,
  "costOfRevenue": 210352000000,
  "grossProfit": 180683000000,
  "operatingIncome": 123216000000,
  "netIncome": 93736000000,
  "eps": 6.08,
  "rawConcepts": {
    "revenues": {
      "tag": "RevenueFromContractWithCustomerExcludingAssessedTax",
      "value": 391035000000, "unit": "USD",
      "accn": "0000320193-24-000123", "form": "10-K", "filed": "2024-11-01"
    }
  },
  "source": "data.sec.gov",
  "scrapedAt": "2026-09-08T06:55:41.000Z"
}
```

#### How the XBRL is normalized

Each normalized field is filled from the first US-GAAP tag in its chain that has a value for the period; `rawConcepts` always records which tag was used.

| Statement | Fields | Example tag chains |
|---|---|---|
| income | `revenues`, `costOfRevenue`, `grossProfit`, `operatingExpenses`, `researchAndDevelopment`, `operatingIncome`, `incomeBeforeTax`, `incomeTaxExpense`, `netIncome`, `eps`, `epsBasic`, `weightedAverageSharesDiluted` | `revenues`: `RevenueFromContractWithCustomerExcludingAssessedTax` → `…IncludingAssessedTax` → `Revenues` → `SalesRevenueNet` → `SalesRevenueGoodsNet` → `RevenuesNetOfInterestExpense`. `grossProfit`: `GrossProfit`, else computed as `revenues − costOfRevenue`. `netIncome`: `NetIncomeLoss` → `ProfitLoss` → `NetIncomeLossAvailableToCommonStockholdersBasic` |
| balance | `totalAssets`, `currentAssets`, `totalLiabilities`, `currentLiabilities`, `stockholdersEquity`, `cashAndEquivalents`, `shortTermInvestments`, `inventory`, `longTermDebt` | `totalLiabilities`: `Liabilities`, else `liabilitiesAndEquity − stockholdersEquity`. `cashAndEquivalents`: `CashAndCashEquivalentsAtCarryingValue` → `CashCashEquivalentsRestrictedCash…` |
| cashflow | `operatingCashFlow`, `investingCashFlow`, `financingCashFlow`, `capitalExpenditures`, `depreciationAndAmortization`, `dividendsPaid`, `shareRepurchases`, `freeCashFlow` | `capitalExpenditures`: `PaymentsToAcquirePropertyPlantAndEquipment` → `PaymentsToAcquireProductiveAssets`. `freeCashFlow`: computed as `operatingCashFlow − capitalExpenditures` |

Four rules make these numbers trustworthy:

1. **Units are never mixed.** Money comes from `USD` series, EPS from `USD/shares`, share counts from `shares`.
2. **Restatements win.** When the same period appears in several filings, the most recently filed value is used — a restated figure supersedes the one originally reported.
3. **Annual reports outrank earnings releases.** A value from a 10-K or 10-Q is preferred over the same value from an 8-K, even if the 8-K was filed later.
4. **Year-to-date figures are discarded.** Six- and nine-month cumulative periods inside 10-Qs are excluded, so a `quarterly` row is always a single quarter.

Fiscal labelling deserves a note, because it is where most XBRL pipelines go wrong. In the SEC's `companyfacts` feed, a fact's `fy` and `fp` describe *the filing it appeared in*, not the fact's own period — so FY2022 comparatives sitting inside a FY2024 10-K carry `fy: 2024`. This Actor cross-references each fact's accession number against the filing's report date and only adopts the SEC's `fy`/`fp` when they genuinely describe that period. Where that check cannot be made, the label is derived from the period end and the company's fiscal year end, and `fiscalLabelSource` tells you which happened.

### Pricing

You pay per result, not per minute. There is no subscription and no platform-usage surcharge.

| Event | What triggers it | Free | Bronze | Silver | Gold |
|---|---|---|---|---|---|
| `actor-start` | Once per run, only after the first paid row is delivered | $0.0005 | $0.0005 | $0.0005 | $0.0005 |
| `company-record` | Each company profile returned | $0.0005 | $0.0005 | $0.0005 | $0.0005 |
| `filing-record` | Each filing or search hit returned | $0.0003 | $0.0003 | $0.00024 | $0.00018 |
| `financial-period` | Each statement × period returned | $0.0004 | $0.0004 | $0.00032 | $0.00024 |

Bronze is the Starter plan, Silver is Scale, Gold is Business. Higher plans pay less per result.

**What that costs in practice**

| You ask for | You get | You pay |
|---|---|---|
| 5 Apple 10-Ks | 5 filing records | $0.0005 + 5 × $0.0003 = **$0.002** |
| 1,000 filings across 20 companies | 1,000 filing records | $0.0005 + 1,000 × $0.0003 = **$0.30** |
| 4 years of income + cash flow for one company | 8 financial periods | $0.0005 + 8 × $0.0004 = **$0.0037** |
| Company profiles for 100 tickers | 100 company records | $0.0005 + 100 × $0.0005 = **$0.051** |

**You are never charged for:** diagnostic rows — an identifier that does not resolve, a company with no filings matching your filters, an SEC outage; **anything at all on a run that returns no paid row** — the `actor-start` fee is billed once, and only right after the first company, filing or financial-period row has been delivered to your dataset, so an SEC outage, an unknown ticker or a filter that matches nothing costs nothing and finishes SUCCEEDED with zero results and a status ending `Nothing was charged.`; rows the Actor could not write because your run or time budget was exhausted; anything beyond the events above — no platform-usage pass-through.

In `financials` mode, a company that files with the SEC but publishes no XBRL facts (some foreign private issuers, and anything filed before 2009) returns one company record with `financials: null`, charged at the `company-record` rate rather than as a financial period.

### Rate limits and the User-Agent requirement

The SEC requires a descriptive `User-Agent` naming the requester with an address it can reach, and — in its own words — "no more than 10 requests per second, regardless of the number of machines used to submit requests". This Actor sends the `userAgentContact` you supply on every request and holds the **whole run** to **8 requests in any rolling second**, a deliberate margin under the published ceiling.

"The whole run" is the part worth stating precisely: the limiter is one shared object, not one per fetcher, so no amount of parallel work inside a run can add up past 8 req/s. It is still one run's ceiling. Nothing coordinates across concurrent runs, so several of your own runs in parallel can add up beyond the SEC's limit — another reason the identity in `userAgentContact` should be yours.

**The SEC answers 403 in two different situations, and this Actor never confuses them:**

| What you get | What it means | What the Actor does | What you do |
|---|---|---|---|
| `rate-limited` | SEC's *Request Rate Threshold Exceeded* page. Too many requests from your identity or address | Slows the whole run down, pauses every request, retries up to twice on a budget that belongs to the run rather than to each request, then stops and says so | Run again in a few minutes; SEC states the block lasts about 10 minutes. Ask for fewer companies per run |
| `user-agent-rejected` | SEC's *Undeclared Automated Tool* page. It did not accept the identity in `userAgentContact` | Fails immediately — retrying the same header cannot succeed | Set `userAgentContact` to your organisation and a working contact address |

Both produce free diagnostic rows, both are named in the run summary row's `secAccessIssue`, and when either one leaves the run with no results the run still finishes SUCCEEDED, with a `0 results.` status message that says which of the two it was. 429 and 5xx are retried with backoff, honouring `Retry-After`.

Two budgets bound one run: `maxRunSecs` (default 240), and a cap of **5 overflow pages per company** when walking a large filer's older filings, so a filter that matches nothing costs at most five extra requests instead of downloading an entire history. When either truncates results, the run says so in its status message, its summary row and the log. A rate backoff never spends more than a third of the run's remaining time either — a run that waits out a block returns nothing at all.

### Use it from an AI agent, or from code

One JSON input, one flat JSON array out — the shape agent runtimes handle best. No browser, no proxy, no credentials beyond `userAgentContact`. The Actor is configured for x402 agentic payments: pay-per-event pricing, event-only charging, limited permissions, no Standby mode. It is callable by name over the **Apify MCP server**, and the **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~sec-edgar-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"filings","identifiers":["AAPL"],"formTypes":["10-K"],"maxFilingsPerCompany":5,"userAgentContact":"Acme Research data@acme.com"}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/sec-edgar-api").call(run_input={
    "mode": "financials",
    "identifiers": ["NVDA", "AMD"],
    "statements": ["income"],
    "periodType": "annual",
    "maxPeriods": 3,
    "userAgentContact": "Acme Research data@acme.com",
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("ok"):
        print(row["companyName"], row["fiscalYear"], row["revenues"], row["netIncome"])
```

**Agent patterns that work well:** answer a question about a company's numbers with `financials` and a small `maxPeriods`, citing `rawConcepts` for the exact XBRL tag; find the source document for a claim with `fullTextSearch` on a quoted phrase, then follow `documentUrl`; establish what a company is with `company` before anything else; watch for new filings with `filings`, `formTypes: ["8-K"]` and `filedAfter`.

### FAQ

**Why does one of my companies have no financials?**
XBRL reporting became mandatory in phases starting in 2009, and some filers — notably foreign private issuers filing 20-F or 40-F — are not in the `companyfacts` feed at all. You get a company record with `financials: null` instead of an error, charged at the company rate.

**A number disagrees with what the company reported. Why?**
Almost always a restatement. This Actor returns the most recently filed value for each period, which is the current, restated figure — not necessarily the number printed in the original filing. `rawConcepts[field].filed` and `.accn` tell you which filing the value came from.

**Are amended filings included?**
Yes. Filtering on `10-K` returns both `10-K` and `10-K/A`; `isAmendment` and `baseFormType` separate them. In `financials` mode, values from original 10-K/10-Q filings are preferred over amendments and over 8-K earnings releases.

**Why do `GOOG` and `GOOGL` return one row?**
They are two share classes of one registrant with one CIK. Both resolve to that CIK and it is returned once, with all matched inputs listed in `matchedInputs`, so you are charged once rather than twice.

**How far back does full-text search go?**
EDGAR's full-text index covers filings from 2001 onwards. For anything older, use `filings` mode, which reaches back to the beginning of a company's EDGAR history.

**Does `maxFilingsPerCompany` really reach older filings?**
Yes. The SEC keeps roughly the most recent 1,000 filings in the main submissions file and pushes the rest into overflow pages. The Actor follows those when your limit or date range requires it, and only then — so small requests stay fast. It follows at most five per company; if that truncates your results, the run says so, and narrowing `filedAfter`/`filedBefore` takes you straight to the right pages.

**When is an empty result a failure, and when is it not?**
An empty result is never a failed run. Zero rows because the SEC did not answer — 403, 5xx, timeouts, or a maintenance page instead of JSON — finishes **SUCCEEDED with zero results**, and the status message names the cause, including which of the SEC's two 403s it was, `rate-limited` or `user-agent-rejected`; nothing is charged, start fee included. Zero rows because the answer was empty — a ticker that does not exist, a CIK with no submissions record, a form filter matching no filings, a company with no XBRL facts — finishes the same way, with diagnostic rows naming each one. Those are answers, just not the ones you hoped for, and you are not charged for them — neither the diagnostic rows nor the start fee. A run finishes **FAILED** only when the Actor itself hit an error.

**The run says `rate-limited`. What now?**
The SEC throttles by requester, not by machine, and states that access is limited for about ten minutes once its 10 req/s ceiling is crossed. This Actor holds a whole run to 8 req/s, so a rate block usually means other traffic sharing your identity or your address — including your own parallel runs. Wait a few minutes and run again, or split the work into smaller runs. Nothing is charged for the rows that could not be fetched.

**Is any of this investment advice?**
No. This Actor reproduces public regulatory filings. It does not interpret them.

### Legal

- **Not affiliated with, endorsed by, or sponsored by the U.S. Securities and Exchange Commission.** "EDGAR" and "SEC" are used descriptively to identify the public data source.
- All data comes from **US federal public records** that the SEC publishes explicitly for programmatic access. No login, no authentication, no paywall is bypassed.
- The Actor honours the SEC's published access policy: a descriptive `User-Agent` on every request and a self-imposed limit of 8 requests per second — counted across the whole run, not per fetcher — against a published ceiling of 10.
- **Nothing here is investment, legal, or tax advice.** Filing data may contain errors, omissions, or restatements; verify against the source documents, which are linked on every row.
- Company officers' names appear in some filings as a matter of public record. This Actor does not extract, enrich, or infer personal data beyond what the SEC itself publishes in the structured fields listed above.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Sponsor & Advertiser Finder — YouTube, Podcasts & Newsletters](https://apify.com/insight.solutions/sponsorship-intelligence-api) — which brands sponsor which YouTube channels, podcasts and Substack newsletters, with promo codes, offers and sponsor links, company-level only.
- [Google Ads Transparency API — Advertisers, Ads & Creatives](https://apify.com/insight.solutions/google-ads-transparency-api) — every ad a verified advertiser runs on Google, from the Ads Transparency Center, by brand name, AR id or domain: format, first and last shown, days shown and preview links, individuals excluded.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Repos, Trending & Releases API](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Company Contact Finder](https://apify.com/insight.solutions/company-contact-finder) — company names in, each one's verified website with its business emails, phone numbers and social profiles out.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [Litigation Signals API — Lawsuits, Settlements & Investigations](https://apify.com/insight.solutions/litigation-signals-api) — lawsuits, settlements and investigations per public company from SEC 10-K, 10-Q and 8-K disclosures, press wires and SEC, FTC and DOJ notices, company-level only.
- [Funding Signals API — Rounds from SEC Form D, Wires & News](https://apify.com/insight.solutions/funding-signals-api) — who just raised money: one row per funding round from SEC Form D filings, press wires and Google News, with amount, round, investors, industry and state, company-level only.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs API](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Careers Page Jobs API — Open Roles from Any Company's Site](https://apify.com/insight.solutions/careers-page-jobs-api) — open roles from any company's own careers site: domain in, the platform recognised (Eightfold, Phenom, Jibe, iCIMS, Google, Amazon, 14 ATSs) or the site's structured data read, one row per job.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Price Tracker API — Prices, Stock & Changes from Any Retailer](https://apify.com/insight.solutions/price-tracker-api) — price, stock, list price and discount from any product URL, read from the page's structured data, with price-drop and restock rows between runs.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events API](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Shopify Store Finder — Discover & Verify Stores by Niche](https://apify.com/insight.solutions/shopify-store-finder) — Shopify stores by niche and country, each verified on its own storefront, with product count, currency, country, price range and sample products.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

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

What to return. company = the entity record for each identifier. filings = filing history with form and date filters. financials = normalized XBRL income statement, balance sheet and cash flow by period; a company that files with the SEC but publishes no XBRL facts returns one company record with financials: null, billed as a company-record rather than a financial-period. fullTextSearch = EDGAR full-text search across filing documents (2001 onwards).

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

Tickers (AAPL), CIKs (320193 or 0000320193), or company names (Apple Inc.). Required for the company, filings and financials modes. In fullTextSearch mode these are optional and narrow the search to those companies. Multi-class tickers such as GOOG and GOOGL resolve to the same CIK and are returned once.

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

Filter to these EDGAR form types, e.g. 10-K, 10-Q, 8-K, 4, D. Amendments are included automatically: asking for 10-K also returns 10-K/A, flagged with isAmendment. Leave empty for all forms. Used by the filings and fullTextSearch modes.

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

Maximum filings returned per company in filings mode, newest first. In fullTextSearch mode this caps the total number of search hits returned. Older filings beyond the most recent 1,000 are fetched automatically when this limit or the date range requires it.

## `userAgentContact` (type: `string`):

Your organisation and a working contact address, e.g. 'Acme Research data@acme.com'. The SEC requires every automated request to declare who is making it and how to reach them (sec.gov/os/accessing-edgar-data), and answers HTTP 403 without it. The pre-filled value is the publisher's own contact so the example run works out of the box; please replace it with yours for real use, so the SEC reaches you, not us, about your traffic.

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

Search phrase for fullTextSearch mode. Wrap a phrase in double quotes for an exact match, e.g. "material weakness". EDGAR full-text search covers filings from 2001 onwards.

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

Only include filings filed on or after this date (YYYY-MM-DD).

## `filedBefore` (type: `string`):

Only include filings filed on or before this date (YYYY-MM-DD).

## `statements` (type: `array`):

Which financial statements to return in financials mode. One dataset row is produced per statement per fiscal period.

## `periodType` (type: `string`):

Fiscal periods to return in financials mode. Year-to-date figures reported inside quarterly filings (six- and nine-month periods) are deliberately excluded so that quarterly rows are always single quarters.

## `maxPeriods` (type: `integer`):

Maximum fiscal periods returned per company in financials mode, most recent first. When period type is 'both', this limit applies separately to annual and to quarterly periods.

## `includeDocumentUrls` (type: `boolean`):

Include direct links to the primary filing document and to the filing index page on sec.gov.

## `maxRunSecs` (type: `integer`):

Wall-clock budget for the whole run. When it is reached the Actor stops requesting more data, keeps every row it has already written, and says so in the run status. Rows already written are still charged; nothing is charged for work that did not happen.

## Actor input object example

```json
{
  "mode": "filings",
  "identifiers": [
    "AAPL"
  ],
  "formTypes": [
    "10-K"
  ],
  "maxFilingsPerCompany": 5,
  "userAgentContact": "Insight Solutions austinhughhillis@gmail.com",
  "statements": [
    "income",
    "balance",
    "cashflow"
  ],
  "periodType": "annual",
  "maxPeriods": 8,
  "includeDocumentUrls": true,
  "maxRunSecs": 240
}
```

# Actor output Schema

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

Company profiles, filings, financial periods or full-text search hits, depending on the mode you ran. Delivered as JSON items in the default dataset.

# 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 = {
    "mode": "filings",
    "identifiers": [
        "AAPL"
    ],
    "formTypes": [
        "10-K"
    ],
    "maxFilingsPerCompany": 5,
    "userAgentContact": "Insight Solutions austinhughhillis@gmail.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/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 = {
    "mode": "filings",
    "identifiers": ["AAPL"],
    "formTypes": ["10-K"],
    "maxFilingsPerCompany": 5,
    "userAgentContact": "Insight Solutions austinhughhillis@gmail.com",
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/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 '{
  "mode": "filings",
  "identifiers": [
    "AAPL"
  ],
  "formTypes": [
    "10-K"
  ],
  "maxFilingsPerCompany": 5,
  "userAgentContact": "Insight Solutions austinhughhillis@gmail.com"
}' |
apify call insight.solutions/sec-edgar-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/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/h6VCo6270nZgZx2Zt/builds/Kr2uSa3OgS2SsfWuX/openapi.json