SEC EDGAR Form D Without Wrangling the API: Private Raise Data

The SEC’s EDGAR system is fully public and genuinely free — which is exactly why developers underestimate it. There is an API surface at data.sec.gov and a full-text search system, but neither gives you what you actually want for Form D: a clean, structured feed of private-placement raises. Form D is the notice a company files under Regulation D when it raises capital privately, and it’s a goldmine — issuer, offering size, amount sold, investor count, related persons. But getting that out of EDGAR means wrangling XML and XBRL, respecting a fair-use rate rule, sending a real User-Agent on every request, and stitching together two or three endpoints that were never designed to hand you tidy rows. This guide is about getting SEC EDGAR Form D data without wrangling the API yourself.

The API gap, precisely

EDGAR is open data, so calling this an “API gap” needs nuance. The gap isn’t access — it’s shape. Here’s what exists and why none of it is a Form D feed:

• data.sec.gov submissions/company-facts APIs — these are organized around a filer’s CIK and are heavily oriented toward XBRL financial facts from 10-K/10-Q filings. There is no GET /form-d endpoint that returns structured offering data. You can list a CIK’s filings, but you still have to go fetch and parse each one.
• EDGAR full-text search (efts.sec.gov) — lets you search filing text and filter by form type (you can ask for D filings in a date range), returning a JSON list of matching accessions. But it returns pointers to filings, not the parsed contents.
• The filing itself — each Form D submission ships as a primary_doc.xml (a structured XML document following the SEC’s Form D schema). That XML is where the real fields live, and parsing it is on you.

So the workflow is unavoidably multi-step: search/list to find Form D accessions, then fetch and parse each filing’s XML. There is no single endpoint that returns a row per raise. That’s the gap.

The fair-use rules you must respect

EDGAR is free, but the SEC enforces a fair-access policy, and ignoring it gets your IP blocked:

• Send a descriptive User-Agent. The SEC explicitly requires a User-Agent header identifying you (typically a name and contact email). Requests without one are rejected or throttled. This is the single most common reason a first attempt fails.
• Stay under ~10 requests/second. The published fair-use guidance caps automated traffic at roughly 10 requests per second per source. Go over and you’ll be rate-limited or temporarily banned.
• Don’t hammer in parallel from many IPs to dodge the cap — that’s exactly the abuse the policy targets.

These rules are simple but absolute. A polite, single-threaded-ish client with the right header runs all day; a header-less burst gets cut off in seconds.

What data is actually available

A parsed Form D filing is rich. From the XML you get:

• Issuer — entity name, CIK, jurisdiction of incorporation, entity type, year of incorporation, principal address, phone.
• Offering — total offering amount, total amount sold, total remaining to be sold, minimum investment, whether the offering is still open.
• Investors — total number of investors who have already invested, and whether any are non-accredited.
• Related persons — executives, directors and promoters named on the filing, with their roles.
• Offering meta — the exemptions claimed (e.g. Rule 506(b)/506(c)), date of first sale, industry group, and whether it’s an equity, debt, or pooled-investment-fund offering.
• Filing meta — accession number, filing date, form type (D or D/A amendment).

The “total offering amount” and “amount sold” fields are the ones investors and analysts care about most — they’re the closest thing to a public signal of a private raise’s size.

How to walk the surface end to end

The reliable pipeline is three stages:

• Discover filings. Hit EDGAR full-text search for form type D within a date range (or filter by SIC/industry, state, or a CIK list). This returns accession numbers and the filing CIKs. For incremental runs, the daily-index files under Archives/edgar/full-index/ are an alternative discovery path.
• Locate the XML. Each accession maps to a filing folder under Archives/edgar/data/<CIK>/<accession>/. Inside, primary_doc.xml holds the structured Form D content; the folder index (index.json) lists the documents.
• Parse and flatten. Read the XML, pull the issuer/offering/investor/related-person nodes, and emit one flat record per filing. Amendments (D/A) supersede the original, so key on issuer+accession and keep the amendment lineage if you care about how a raise grew over time.

Every one of these requests needs the User-Agent header and the rate cap honored. None of it is hard individually; the work is doing all three reliably, at scale, without tripping the fair-use limits.

A clean output schema

Flatten each filing into one private-raise record:

{
  "issuer_name": "Example Capital Partners LLC",
  "cik": "0001234567",
  "jurisdiction": "DE",
  "entity_type": "Limited Liability Company",
  "year_of_incorporation": "2021",
  "industry_group": "Pooled Investment Fund",
  "exemptions": ["06b"],
  "total_offering_amount": 25000000,
  "total_amount_sold": 18400000,
  "total_remaining": 6600000,
  "minimum_investment": 100000,
  "investor_count": 42,
  "has_non_accredited": false,
  "date_of_first_sale": "2026-02-10",
  "related_persons": [
    {"name": "Jane Doe", "relationship": ["Executive Officer", "Director"]}
  ],
  "form_type": "D",
  "accession_number": "0001234567-26-000045",
  "filing_date": "2026-03-01",
  "filing_url": "https://www.sec.gov/Archives/edgar/data/1234567/000123456726000045/primary_doc.xml",
  "scraped_at": "2026-06-04T00:00:00Z"
}

Schema notes:

• Amounts are numbers, not strings — the XML carries them as text and sometimes uses an “indefinite” flag; coerce carefully and keep a null for indefinite offerings rather than guessing a number.
• exemptions is an array — a filing can claim more than one Rule.
• related_persons is nested — flatten to a string if your sink is tabular, but keep roles.
• Keep accession_number — it’s the stable EDGAR key for dedup and for chaining amendments.
• Always stamp scraped_at — Form D filings get amended, so a dated snapshot tells you which version you captured.

▶ Try the SEC EDGAR Form D Scraper on Apify — discovers Form D filings by date, industry or state and returns clean private-placement rows, handling the XML parsing, the User-Agent rule and the rate cap for you. No auth required.

Use cases

• Private-market intelligence — track who’s raising, how much, and in which sectors, in near real time.
• VC and PE deal sourcing — surface new pooled funds and operating-company raises by industry and geography.
• Sales prospecting — companies that just closed a raise are buyers; Form D is an early signal.
• Research and journalism — quantify private-capital flows by sector or region over time.
• Compliance and KYC — cross-reference issuers and related persons against your own records.

Build it yourself vs. a managed scraper

Building this is realistic — it’s open data and the schema is documented. The work is the plumbing: discovery via full-text search or the index files, mapping accessions to filing folders, parsing the Form D XML into clean numeric fields, handling amendments, and rigidly honoring the User-Agent and 10-req/sec rules so you don’t get blocked mid-run. That’s a solid week, plus ongoing care as filing volumes grow. For a one-off pull of last quarter’s filings it’s worth doing yourself. For a continuous private-raise feed, a managed actor absorbs the multi-endpoint dance and the fair-use compliance and hands you flat rows.

Common pitfalls

• Forgetting the User-Agent. The single most common failure — header-less requests get rejected.
• Exceeding 10 req/sec. The fair-use cap is enforced; pace your client.
• Expecting a structured Form D endpoint. There isn’t one — you must fetch and parse the per-filing XML.
• Ignoring amendments. A D/A revises the original; dedup and lineage matter for accurate offering sizes.
• Coercing “indefinite” amounts to a number. Keep them null rather than inventing a value.

Wrapping up

EDGAR gives you Form D for free, but not in a usable shape — there’s no structured private-raise endpoint, just full-text search that returns pointers and per-filing XML you have to parse, all under a fair-use rule that demands a real User-Agent and caps you near 10 requests a second. Getting SEC EDGAR Form D data without wrangling the API means doing the three-stage discover-fetch-parse pipeline cleanly and respectfully. Do it yourself for a quarterly snapshot, or use a managed scraper that handles the XML, the amendments and the fair-use limits for a continuous private-raise feed.

▶ Open the SEC EDGAR Form D Scraper on Apify — structured private-placement data with issuer, offering amount, amount sold, investors and related persons, normalized and ready for analysis. No API key required, because EDGAR’s surface was never built to give you one.