# SEC EDGAR Scraper: Filings, Form 4, 13F, XBRL (`tiger19935/sec-edgar-scraper`) Actor

SEC EDGAR scraper for structured filings: 10-K/10-Q/8-K sections as Markdown, parsed Form 4 insider trades, 13F holdings, Form D and XBRL financials as clean rows. Watchlist monitor with Slack alerts. Official endpoints, pay per filing from $0.001.

- **URL**: https://apify.com/tiger19935/sec-edgar-scraper.md
- **Developed by:** [Andrew Boiko](https://apify.com/tiger19935) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 filing index rows

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: Filings, Form 4, 13F, XBRL

SEC EDGAR Scraper turns raw filings into data you can use: parsed Form 4 insider trades, 13F institutional holdings, Form D offerings, clean annual and quarterly financial statements from XBRL, and 10-K, 10-Q and 8-K text split by Item and converted to Markdown for LLM pipelines. It also monitors a watchlist and sends new filings to Slack or any webhook.

Everything comes from the official SEC endpoints (submissions, company facts, full-text search, the latest-filings feed and the Archives folder). No API key, no login, no HTML scraping of search pages, no blocks. You pay per filing, from $0.001.

### What does SEC EDGAR Scraper: Filings, Form 4, 13F, XBRL do?

Pick a `mode`, list tickers or CIK numbers, and the Actor returns structured rows:

| Mode | What you get | Billed event |
| --- | --- | --- |
| `filings` | Filing index rows: form, filing and report dates, accession number, 8-K item codes, document URL | `filing-row` |
| `parse` | Form 4 insider transactions (non-derivative and derivative, owner, role, price, shares, A/D code), 13F-HR holdings (issuer, CUSIP, value, shares), Form D basics | `parsed-form` |
| `markdown` | 10-K, 10-Q and 8-K converted to Markdown, split by Item (1A Risk Factors, 7 MD\&A, 2.02 and so on), tables kept as Markdown tables | `filing-markdown` |
| `financials` | Annual and quarterly income statement, balance sheet and cash flow rows built from XBRL company facts, plus a CSV file | `financials-pull` |
| `monitor` | Only filings that are new since the last run, state kept in a named key-value store, optional Slack or webhook POST | `filing-row` |
| `search` | EDGAR full-text search results as filing rows | `filing-row` |
| `latest` | Newest filings from the SEC latest-filings feed, optionally limited to your watchlist | `filing-row` |

Tickers are resolved to CIK through the official `company_tickers.json` file. You can also pass CIK numbers directly, which is how you point the `parse` mode at an institution for 13F filings.

### Why use SEC EDGAR Scraper: Filings, Form 4, 13F, XBRL?

- **Parsed, not raw.** Many EDGAR tools stop at the filing index or raw HTML. This Actor parses the Form 4 and 13F XML tables, and it splits long reports into Item sections you can feed to an LLM one section at a time, with an optional token budget per section.
- **Cheap per filing.** One billed event covers one whole filing: $0.003 for a parsed Form 4 or 13F (a 13F can hold thousands of holdings), $0.01 for a full 10-K as Markdown. Typical paid SEC data APIs and chunk-priced tools cost more for the same volume, and there is no monthly fee here.
- **Built-in watchlist and alerts.** The `monitor` mode remembers what it has already seen and posts only new filings to Slack or any HTTPS webhook. Schedule it every 15 minutes with an Apify schedule.
- **Polite to SEC by design.** A declared User-Agent with your contact email and a hard limit of 8 requests per second (SEC allows 10), with retries and backoff on 429 and 5xx.
- **Works for agents.** Array input, flat rows and token budgets suit MCP tools and trading or research agents. Output is public filing data only.

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

Pay per event. Prices per single event in USD, by Apify plan:

| Event | FREE | BRONZE | SILVER | GOLD |
| --- | --- | --- | --- | --- |
| `filing-row` (one filing index row) | $0.0010 | $0.0009 | $0.0008 | $0.0007 |
| `parsed-form` (one Form 4, 13F-HR or Form D parsed) | $0.0030 | $0.0027 | $0.0024 | $0.0021 |
| `filing-markdown` (one 10-K, 10-Q or 8-K as Markdown) | $0.0100 | $0.0090 | $0.0080 | $0.0070 |
| `financials-pull` (one company, all statements) | $0.0100 | $0.0090 | $0.0080 | $0.0070 |

Examples at FREE prices: 1,000 filing rows = $1.00. 1,000 parsed Form 4 filings = $3.00. 100 annual reports as Markdown = $1.00. 100 companies' financial statements = $1.00. Apify's own run start event is separate and not added by this Actor.

Fair-use notes:

- Free Apify plan users get up to 25 results per run. The run then ends normally with the message "Free tier limit reached (25 results). Upgrade to a paid Apify plan for unlimited results."
- Set `maxItems` to cap results per run, and Apify's `maxTotalChargeUsd` to cap spend. The Actor stops gracefully when either limit is reached.
- You are never charged for failed filings, filings that could not be parsed, empty results or duplicates.
- With `flattenRows` the output has one row per transaction or holding, but billing stays one event per filing.

### Input

Main fields (all have defaults, a run with no input works):

| Field | Type | Meaning |
| --- | --- | --- |
| `contactEmail` | string | Your email, sent in the SEC User-Agent. Required by SEC rules. The placeholder `you@example.com` works but logs a warning. |
| `mode` | select | `filings`, `parse`, `markdown`, `financials`, `monitor`, `search`, `latest` |
| `companies` | array | Tickers or CIKs, for example `["AAPL","MSFT","1067983"]` |
| `formTypes` | array | `10-K`, `10-Q`, `8-K`, `4`, `13F-HR`, `D`, `S-1`, `DEF 14A` ... |
| `includeAmendments` | boolean | Also return `/A` forms |
| `dateFrom`, `dateTo` | string | Filing date range, `YYYY-MM-DD` |
| `maxFilingsPerCompany` | integer | Newest first, default 10 |
| `maxItems` | integer | Cap on billed results for the run |
| `searchQuery` | string | Full-text query for `search` mode |
| `sections` | array | Item codes to keep in `markdown` mode, for example `["1A","7"]` |
| `maxTokensPerSection` | integer | Truncate each section to about this many tokens |
| `includeFullMarkdown` | boolean | Add one combined Markdown string |
| `flattenRows` | boolean | One row per transaction, holding or financial fact |
| `maxHoldingsPerFiling` | integer | Keep only the N largest 13F holdings |
| `statements`, `periods`, `yearsBack`, `deriveQ4` | various | `financials` mode options |
| `monitorName`, `stateStoreName`, `lookbackDaysFirstRun`, `webhookUrl`, `resetState` | various | `monitor` mode options. `webhookUrl` is stored as a secret. |
| `maxRequestsPerSecond` | integer | Never above 8 |
| `proxyConfiguration` | object | Off by default. Turn on only if SEC answers 403 or 429 for your IP range. |

Example 1: latest filings index for three tickers

```json
{
  "contactEmail": "you@yourcompany.com",
  "mode": "filings",
  "companies": ["AAPL", "MSFT", "NVDA"],
  "formTypes": ["10-K", "10-Q", "8-K"],
  "maxFilingsPerCompany": 20
}
```

Example 2: insider trading data as one row per transaction

```json
{
  "contactEmail": "you@yourcompany.com",
  "mode": "parse",
  "companies": ["TSLA"],
  "formTypes": ["4"],
  "maxFilingsPerCompany": 25,
  "flattenRows": true
}
```

Example 3: watchlist alerts for new 8-K and Form 4 filings to Slack

```json
{
  "contactEmail": "you@yourcompany.com",
  "mode": "monitor",
  "companies": ["AAPL", "NVDA", "AMD"],
  "formTypes": ["8-K", "4"],
  "monitorName": "tech-watchlist",
  "lookbackDaysFirstRun": 3,
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ"
}
```

### Output example

Illustrative output, shortened. Field values are examples, not live data.

Filing row (`filings`, `search`, `latest`, `monitor`):

```json
{
  "recordType": "filing",
  "cik": "0000320193",
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "accessionNumber": "0000320193-26-000010",
  "form": "8-K",
  "filingDate": "2026-10-10",
  "reportDate": "2026-10-09",
  "items": ["2.02", "9.01"],
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000010/a8k.htm"
}
```

Form 4 transaction (`parse` with `flattenRows`):

```json
{
  "recordType": "form4-transaction",
  "ticker": "AAPL",
  "ownerName": "COOK TIMOTHY D",
  "ownerRole": "Director, Chief Executive Officer",
  "table": "non-derivative",
  "security": "Common Stock",
  "transactionDate": "2026-10-01",
  "transactionCode": "S",
  "acquiredDisposed": "D",
  "shares": 1000,
  "pricePerShare": 250.5,
  "valueUsd": 250500,
  "sharesOwnedAfter": 3280000,
  "tenb51Plan": true
}
```

Markdown section (`markdown`):

```json
{
  "recordType": "filing-markdown",
  "form": "10-K",
  "sectionCount": 2,
  "estimatedTokensTotal": 11800,
  "sections": [
    { "part": "I", "item": "1A", "title": "Risk Factors", "estimatedTokens": 7400, "markdown": "Competition is intense..." }
  ]
}
```

Financial row (`financials` with `flattenRows`):

```json
{
  "recordType": "financial-row",
  "statement": "income",
  "concept": "Revenue",
  "xbrlTag": "RevenueFromContractWithCustomerExcludingAssessedTax",
  "periodType": "annual",
  "fiscalYear": 2025,
  "periodEnd": "2025-09-27",
  "value": 391035000000,
  "derived": false,
  "form": "10-K"
}
```

Every run also writes an `OUTPUT` record with counts, charged events, an estimate of the charge at FREE prices and any warnings. In `financials` mode a `financials-<ticker>.csv` file is stored in the key-value store as well.

### How to use SEC EDGAR Scraper: Filings, Form 4, 13F, XBRL (tutorial)

1. Open the Actor and type your own email into `contactEmail`. SEC asks every automated client to identify itself.
2. Choose a `mode`. For insider trading data choose `parse` with form type `4`. For holdings of a fund choose `parse`, form type `13F-HR` and the fund's CIK. For report text choose `markdown`.
3. Add tickers or CIKs to `companies` and set `maxFilingsPerCompany` and `maxItems` so the cost is predictable.
4. Click Start. Open the Output tab for the dataset table, or the key-value store for the `OUTPUT` summary and CSV files.
5. Export as JSON, CSV or Excel, call it from the API, or put it on an Apify schedule. For alerts, use `monitor` mode and paste a Slack webhook URL.

Tips: for an LLM, use `markdown` with `sections: ["1A","7"]` and `maxTokensPerSection: 6000`. For spreadsheets, use `flattenRows: true`. In `financials` mode, Q4 values are derived as full year minus Q1 to Q3 and are marked `derived: true`.

### Run via API

Synchronous call that returns dataset items:

```bash
curl -X POST "https://api.apify.com/v2/acts/tiger19935~sec-edgar-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"contactEmail":"you@yourcompany.com","mode":"parse","companies":["NVDA"],"formTypes":["4"],"maxFilingsPerCompany":10,"flattenRows":true}'
```

Node.js:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('tiger19935/sec-edgar-scraper').call({
  contactEmail: 'you@yourcompany.com',
  mode: 'markdown',
  companies: ['MSFT'],
  formTypes: ['10-K'],
  sections: ['1A', '7'],
  maxTokensPerSection: 6000,
  maxFilingsPerCompany: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].sections.map((s) => s.title));
```

MCP: the Actor takes array input and returns flat JSON, so it works as a tool through the Apify MCP server. Add `tiger19935/sec-edgar-scraper` to the tools list of the Apify MCP server and your agent can call it with the same input as above.

### Integrations

- **n8n and Make:** use the Apify node or module, run the Actor, read the dataset. Trigger on a schedule or a webhook.
- **Zapier:** use the Apify app, action "Run Actor", then map dataset fields into your Zap.
- **Google Sheets:** use the Apify integration to export each run to a sheet, ideal with `flattenRows`.
- **Slack and webhooks:** `monitor` mode posts `{ "text": ..., "filings": [...] }` to any HTTPS URL, compatible with Slack incoming webhooks. You can also use Apify run webhooks.
- **MCP agents:** call it from Claude, ChatGPT or custom agents through the Apify MCP server.

### Legal / ethical use

This Actor reads public filings from sec.gov through the official data endpoints. SEC fair-access rules require a declared User-Agent and at most 10 requests per second. The Actor identifies itself with your `contactEmail` and stays at 8 requests per second or below. Do not raise the load by running many copies in parallel from one IP. Filings contain names of company officers and directors as published by the SEC. If you store or publish personal data, you are responsible for your own compliance, for example with GDPR. The Actor does not log in anywhere and does not access private data.

The data is public filing data only. It is not financial, investment, legal or tax advice, and parsed or derived values (for example the derived Q4 figures or the 13F value basis) should be checked against the original filing before you rely on them.

### FAQ and support

**Is it using official SEC data?**
Yes. It uses the EDGAR submissions, company facts and full-text search endpoints, the latest-filings feed and the Archives folder, with a declared User-Agent and rate limiting below the SEC limit.

**Can I use it for trading agents?**
Yes. Outputs are structured, flat rows are available, sections can be token-budgeted, and the Actor works as an MCP tool. It delivers data, not signals.

**Does it give financial advice?**
No. It delivers public filing data only.

**Do I need an API key?**
No. You only need to provide an email address for the SEC User-Agent.

**How do I get 13F holdings for a fund?**
Use `mode: "parse"`, `formTypes: ["13F-HR"]` and the fund manager's CIK in `companies`. Since 2023 the SEC reports 13F values in whole dollars. For older filings the Actor multiplies the reported thousands by 1,000 and says so in `valueBasis`.

**Why does a Form 4 search by ticker show the company's filings?**
Form 4 filings are listed under the issuer company as well as under the insider. Searching by the issuer ticker returns insider trades in that company.

**Why are some Item sections missing?**
Item headings in EDGAR documents are not standardized. If no headings are detected, the whole document is returned as one section and a warning is added. Use `includeFullMarkdown` or open an issue with the filing URL.

**Why did the run stop at 25 results?**
You are on the Apify free plan, which is capped at 25 results per run. Upgrade to a paid plan to remove the cap.

**Why do I get HTTP 403 or 429 from SEC?**
Use a real `contactEmail`, keep `maxRequestsPerSecond` low and avoid parallel runs from the same IP. If your IP range is throttled, enable `proxyConfiguration`.

Support: open a ticket in the Issues tab of this Actor. Replies come within 12 hours. Please include the run link and the filing URL if a filing does not parse.

### More tools by the same author

- [Prozorro & TED Tenders Scraper](https://apify.com/tiger19935/prozorro-ted-tenders-scraper) - public tenders from Ukraine and the EU
- [Billing & Payment Stack Detector](https://apify.com/tiger19935/billing-stack-detector) - which payment gateway a website uses
- [Website Technology Detector](https://apify.com/tiger19935/website-technology-detector) - tech stack of any site
- [Decision-Maker Contacts](https://apify.com/tiger19935/decision-maker-contacts) - people and roles at a company

### Related searches

sec edgar scraper, sec edgar api, form 4 insider trading data, 13f holdings api, 10-k to markdown, xbrl financial data, sec filings monitor, edgar full text search, insider transactions csv, 8-k alerts, sec filings for llm, company financials api.

# Changelog

This Actor's version history is a separate document: https://apify.com/tiger19935/sec-edgar-scraper/changelog.md

# Actor input Schema

## `contactEmail` (type: `string`):

SEC requires every automated client to declare a contact in the User-Agent header. Use your own email. The placeholder works but triggers a warning and may get throttled.

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

filings = filing index rows; parse = parsed Form 4 / 13F-HR / Form D; markdown = 10-K/10-Q/8-K split by Item into Markdown; financials = XBRL statements; monitor = only filings new since the last run (+ optional webhook); search = EDGAR full-text search; latest = newest filings feed.

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

Tickers (AAPL, MSFT) or CIK numbers (320193). For 13F, pass the institution CIK (e.g. 1067983). Needed for every mode except search and latest.

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

Filter by form: 10-K, 10-Q, 8-K, 4, 13F-HR, D, S-1, DEF 14A... parse supports 4, 13F-HR, D; markdown supports 10-K, 10-Q, 8-K. In search mode leave empty for all forms.

## `includeAmendments` (type: `boolean`):

Also return amended filings such as 10-K/A or 4/A.

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

Only filings filed on or after this date. Leave empty for no lower bound.

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

Only filings filed on or before this date. Leave empty for no upper bound.

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

Newest first. Applies to filings, parse, markdown (monitor always checks the latest 100).

## `maxItems` (type: `integer`):

Hard cap on billed results for the whole run. 0 means no cap (the free plan is still capped at 25).

## `searchQuery` (type: `string`):

Used by mode search. Supports EDGAR syntax, for example "going concern" or "supply chain" AND tariff. Covers filings from 2001 on.

## `sections` (type: `array`):

Item codes to keep, e.g. 1A (Risk Factors), 7 (MD\&A), 2.02 for 8-K. Empty keeps all sections.

## `maxTokensPerSection` (type: `integer`):

Truncate each Markdown section to about this many tokens (4 characters per token). 0 keeps full text. Useful for LLM context windows.

## `includeFullMarkdown` (type: `boolean`):

Adds a single markdown field with all kept sections joined, besides the sections array.

## `flattenRows` (type: `boolean`):

parse: one dataset row per Form 4 transaction or 13F holding. financials: one row per fact. Billing is unchanged (one event per filing or company).

## `maxHoldingsPerFiling` (type: `integer`):

Keep only the N largest holdings by value in each 13F-HR (0 = all). Totals still cover the full table.

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

financials mode: income, balance, cashflow.

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

financials mode: annual (10-K), quarterly (10-Q) or both.

## `yearsBack` (type: `integer`):

financials mode: how many fiscal years back to include.

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

10-K files carry no stand-alone Q4. When on, Q4 = full year minus Q1 to Q3 (marked derived = true).

## `monitorName` (type: `string`):

Namespace for saved state, so you can run several watchlists with different settings.

## `stateStoreName` (type: `string`):

Named key-value store that remembers the filings already seen (persists between runs).

## `lookbackDaysFirstRun` (type: `integer`):

monitor mode: on the first run for a company, report filings from the last N days (0 = just set the baseline, report nothing).

## `webhookUrl` (type: `string`):

monitor mode: POST of {text, filings} when new filings are found. Works with Slack incoming webhooks. Not billed.

## `resetState` (type: `boolean`):

Forget previously seen filings for this monitor name and start from a fresh baseline.

## `maxRequestsPerSecond` (type: `integer`):

Request rate towards SEC. SEC allows 10 per second; the actor never exceeds 8.

## `proxyConfiguration` (type: `object`):

Off by default: SEC endpoints are public and need no proxy. Enable only if your IP range gets HTTP 403 or 429 from SEC.

## Actor input object example

```json
{
  "contactEmail": "you@example.com",
  "mode": "filings",
  "companies": [
    "AAPL"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "includeAmendments": false,
  "maxFilingsPerCompany": 10,
  "maxItems": 50,
  "maxTokensPerSection": 0,
  "includeFullMarkdown": false,
  "flattenRows": false,
  "maxHoldingsPerFiling": 0,
  "statements": [
    "income",
    "balance",
    "cashflow"
  ],
  "periods": "both",
  "yearsBack": 5,
  "deriveQ4": true,
  "monitorName": "default",
  "stateStoreName": "sec-edgar-monitor-state",
  "lookbackDaysFirstRun": 3,
  "resetState": false,
  "maxRequestsPerSecond": 8,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset items (filing rows, parsed forms, Markdown sections or financial statements).

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

Dataset overview view.

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

Counts, charged events, estimated cost and warnings.

# 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 = {
    "contactEmail": "you@example.com",
    "mode": "filings",
    "companies": [
        "AAPL"
    ],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K"
    ],
    "maxFilingsPerCompany": 10,
    "maxItems": 50,
    "maxTokensPerSection": 0,
    "maxHoldingsPerFiling": 0,
    "statements": [
        "income",
        "balance",
        "cashflow"
    ],
    "periods": "both",
    "yearsBack": 5,
    "monitorName": "default",
    "stateStoreName": "sec-edgar-monitor-state",
    "lookbackDaysFirstRun": 3,
    "maxRequestsPerSecond": 8,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tiger19935/sec-edgar-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "contactEmail": "you@example.com",
    "mode": "filings",
    "companies": ["AAPL"],
    "formTypes": [
        "10-K",
        "10-Q",
        "8-K",
    ],
    "maxFilingsPerCompany": 10,
    "maxItems": 50,
    "maxTokensPerSection": 0,
    "maxHoldingsPerFiling": 0,
    "statements": [
        "income",
        "balance",
        "cashflow",
    ],
    "periods": "both",
    "yearsBack": 5,
    "monitorName": "default",
    "stateStoreName": "sec-edgar-monitor-state",
    "lookbackDaysFirstRun": 3,
    "maxRequestsPerSecond": 8,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tiger19935/sec-edgar-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "contactEmail": "you@example.com",
  "mode": "filings",
  "companies": [
    "AAPL"
  ],
  "formTypes": [
    "10-K",
    "10-Q",
    "8-K"
  ],
  "maxFilingsPerCompany": 10,
  "maxItems": 50,
  "maxTokensPerSection": 0,
  "maxHoldingsPerFiling": 0,
  "statements": [
    "income",
    "balance",
    "cashflow"
  ],
  "periods": "both",
  "yearsBack": 5,
  "monitorName": "default",
  "stateStoreName": "sec-edgar-monitor-state",
  "lookbackDaysFirstRun": 3,
  "maxRequestsPerSecond": 8,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tiger19935/sec-edgar-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8s9YBZve30IbgTBf8/builds/RZq14rFGvWAHNuScr/openapi.json