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:

{
  "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:

{
  "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:

{
  "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.