# SEC EDGAR 10-K Parser to Markdown Sections (`awesome_highboy/edgar`) Actor

Parse SEC EDGAR filings (10-K, 10-Q, 8-K) into section-segmented Markdown. Splits by Item headings (Item 1A Risk Factors, Item 7 MD\&A) into per-section records with sha256 content hashes. RAG/LLM-ready sections, dedupe-friendly, keyless official SEC API. Pay-per-filing.

- **URL**: https://apify.com/awesome\_highboy/edgar.md
- **Developed by:** [Adam](https://apify.com/awesome_highboy) (community)
- **Categories:** Developer tools, AI, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 filing parseds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## EDGAR Forge: SEC Filings to LLM-Ready Markdown Sections

Parse SEC EDGAR filings — 10-K, 10-Q, 8-K, and other text filings — into clean, section-per-record Markdown with deterministic `sha256` content hashes. Free US government data, no API key, no LLM, no hallucination.

### Why this Actor

SEC EDGAR publishes hundreds of thousands of company filings as free, public text. The raw files are dense SGML/HTML blobs — useless to an LLM or a vector store without parsing. This Actor turns each filing into **one structured dataset record per `Item` section** so you can feed exactly the sections you want into a RAG pipeline, embedding job, or LLM context window.

### Use cases

- **Financial research AI** — pull `Item 7. Management's Discussion and Analysis` sections from a portfolio of companies, embed them, and ask cross-filing questions with a RAG model.
- **Risk factor monitoring** — track `Item 1A. Risk Factors` across annual 10-K filings to detect when a company adds or changes material risk disclosures.
- **Earnings call prep** — ingest the latest 10-Q before an earnings call to give an analyst or LLM the raw financial narrative for Q&A.
- **Competitive due diligence** — batch-parse the `Item 1. Business` sections from every competitor's 10-K to build a structured view of what each company says it does.
- **Sector analysis** — collect thousands of `Item 1. Business` blurbs across an industry, chunk them into embeddings, and cluster by semantic similarity.
- **LLM context injection** — pull a single specific Item into a prompt instead of pasting a 200-page filing; section-level records let you surgically pick what the model needs to see.

### What it does

EDGAR Forge takes a list of SEC EDGAR filing URLs and, for each one:

1. Fetches the filing text over HTTP with no API key, sending a descriptive `User-Agent` (name + contact email) as the request header, which SEC fair-access requires.
2. Segments the document into sections by detecting `Item N.` headings (e.g. `Item 1. Business`, `Item 1A. Risk Factors`, `Item 7. Management's Discussion`).
3. Emits one `section` record per detected section, each containing the section heading, its body text (in the `markdown` field), and a `sha256` content hash. If no `Item` headings are found, it emits a single `FULL` section containing the whole document.
4. Carries through any `cik`, `ticker`, and `filingType` you supply alongside each URL so records stay traceable.
5. Writes one `run_summary` record at the end with the totals for the run.

Filings that fail to fetch are skipped (and not billed), so one bad URL never fails the whole run.

### Quick start

Minimum input to parse one filing:

```json
{
  "filings": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/aapl-20230930.htm",
      "ticker": "AAPL",
      "filingType": "10-K"
    }
  ],
  "ownership_attestation": true
}
````

The Actor fetches the filing, detects all `Item` headings, and emits one `section` record per Item plus a `run_summary`. EDGAR filing URLs are found on the company's filings page at `https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=<ticker>&type=10-K`.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `filings` | array | Yes | SEC EDGAR filing URLs (US gov open data). Each item is either a plain URL string, or an object `{ url, cik, ticker, filingType }` so the metadata is attached to that filing's output records. |
| `userAgent` | string | No | A descriptive `User-Agent` (your name + contact email) that SEC fair-access requires. Used as the request header when fetching filings. A built-in default is used if you omit it. |
| `ownership_attestation` | boolean | Yes | You must confirm you will honor SEC fair-access terms. The run is rejected before any work or billing if this is not `true`. |

### Sample output

A `section` record from a parsed 10-K filing:

```json
{
  "record_type": "section",
  "ticker": "AAPL",
  "cik": "320193",
  "filing_type": "10-K",
  "section": "Item 1A. Risk Factors",
  "markdown": "The following discussion of risk factors contains forward-looking statements...\n\nMacroeconomic and Industry Risks\n\nThe Company's operations and performance depend significantly on worldwide economic conditions...",
  "content_hash": "sha256:3f4a8c1d2e9b7f6a1c3d5e7f9a0b2c4d6e8f0a1b3c5d7e9f1a3b5c7d9e1f3a5b"
}
```

And the `run_summary` that closes every run:

```json
{
  "record_type": "run_summary",
  "filings_parsed": 1,
  "sections_emitted": 14
}
```

### Output schema

Records are pushed to the default dataset. Every record has a `record_type` field.

**`section`** — one per detected filing section:

| Field | Type | Description |
|---|---|---|
| `record_type` | string | Always `"section"`. |
| `cik` | string | CIK you supplied for the filing (or empty). |
| `ticker` | string | Ticker you supplied for the filing (or empty). |
| `filing_type` | string | Filing type you supplied (or empty). |
| `section` | string | The detected section heading (e.g. `Item 1A. Risk Factors`), or `FULL` when no `Item` headings were found. |
| `markdown` | string | The section body text (a trimmed slice of the filing). |
| `content_hash` | string | Deterministic hash of the section body, in the form `sha256:<64 hex chars>`. |

**`run_summary`** — exactly one per run:

| Field | Type | Description |
|---|---|---|
| `record_type` | string | Always `"run_summary"`. |
| `filings_parsed` | integer | Number of filings successfully fetched and segmented. |
| `sections_emitted` | integer | Total `section` records produced across the run. |

### Pricing

This Actor uses Pay-Per-Event pricing:

| Event | When it fires | Price |
|---|---|---|
| `actor_run_start` | Once per run, after the gates pass | $0.005 |
| `filing_parsed` | Once per filing that is successfully fetched and segmented | $0.003 |

Sections are emitted as data but are **not** billed separately — you only pay the per-filing unit, which avoids double-charging the same parse. Filings that fail to fetch cost $0.

**Example:** parsing 10 filings → `$0.005` (run start) + `10 × $0.003` = **$0.035 total**.

### Guarantees

- **Deterministic, idempotency-friendly output.** Every section carries a `sha256:` content hash computed directly from its body, so you can dedupe, cache, and detect changes across runs without re-diffing raw text.
- **Nothing is invented.** Sections come straight from the filing text via heading detection; metadata fields like `cik`, `ticker`, and `filing_type` are passed through exactly as you supply them and left empty otherwise, never fabricated.
- **Compliance built in.** A required ownership attestation gate rejects the run with zero billing if you do not confirm SEC fair-access terms, and every fetch sends a descriptive contact `User-Agent`.
- **Pre-segmented for downstream use.** Output is already split into per-section records with stable hashes, ready to feed directly into Pinecone, Weaviate, pgvector, or any other vector store.

### About

This Actor is AI-authored and operated under the publisher's LLC. `Actor.charge()` is used only to bill the customer for the Pay-Per-Event units described above — the Actor has no payout or money-out capability of any kind.

# Actor input Schema

## `filings` (type: `array`):

Official SEC EDGAR filing URLs (US gov open data).

## `userAgent` (type: `string`):

SEC fair-access requires a descriptive User-Agent with contact email.

## `ownership_attestation` (type: `boolean`):

I will honor SEC fair-access terms (REQUIRED)

## Actor input object example

```json
{
  "filings": [
    "https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/aapl-20230930.htm"
  ],
  "userAgent": "Operator EDGAR Forge contact@example.com",
  "ownership_attestation": true
}
```

# 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 = {
    "filings": [
        "https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/aapl-20230930.htm"
    ],
    "userAgent": "Operator EDGAR Forge contact@example.com",
    "ownership_attestation": true
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "filings": ["https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/aapl-20230930.htm"],
    "userAgent": "Operator EDGAR Forge contact@example.com",
    "ownership_attestation": True,
}

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

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

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

```

## CLI example

```bash
echo '{
  "filings": [
    "https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/aapl-20230930.htm"
  ],
  "userAgent": "Operator EDGAR Forge contact@example.com",
  "ownership_attestation": true
}' |
apify call awesome_highboy/edgar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=awesome_highboy/edgar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR 10-K Parser to Markdown Sections",
        "description": "Parse SEC EDGAR filings (10-K, 10-Q, 8-K) into section-segmented Markdown. Splits by Item headings (Item 1A Risk Factors, Item 7 MD&A) into per-section records with sha256 content hashes. RAG/LLM-ready sections, dedupe-friendly, keyless official SEC API. Pay-per-filing.",
        "version": "0.1",
        "x-build-id": "HP1FlaKPhON9gfoiB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/awesome_highboy~edgar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-awesome_highboy-edgar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/awesome_highboy~edgar/runs": {
            "post": {
                "operationId": "runs-sync-awesome_highboy-edgar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/awesome_highboy~edgar/run-sync": {
            "post": {
                "operationId": "run-sync-awesome_highboy-edgar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "filings",
                    "ownership_attestation"
                ],
                "properties": {
                    "filings": {
                        "title": "Filings (SEC EDGAR URLs or {url,cik,ticker,filingType})",
                        "type": "array",
                        "description": "Official SEC EDGAR filing URLs (US gov open data).",
                        "default": [
                            "https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/aapl-20230930.htm"
                        ]
                    },
                    "userAgent": {
                        "title": "SEC User-Agent (name + email, required by SEC)",
                        "type": "string",
                        "description": "SEC fair-access requires a descriptive User-Agent with contact email."
                    },
                    "ownership_attestation": {
                        "title": "I will honor SEC fair-access terms (REQUIRED)",
                        "type": "boolean",
                        "description": "I will honor SEC fair-access terms (REQUIRED)",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```