Startup Funding Rounds: SEC Form D Feed

What does SEC Form D Feed do?

SEC Form D Feed gives you the new private raises filed with SEC on Form D, across the whole market. You do not name companies. You pick the raises you care about: industry group, the state or country of the issuer, a range for the offering amount, the exemption claimed, whether pooled investment funds count and whether amendments count. The Actor reads SEC's daily index for the latest filing days, opens every new Form D in it, and returns one row per raise that matches, with the amounts already parsed: total offering, amount sold, amount remaining, minimum investment, date of first sale and number of investors.

Run it on a schedule. The first run returns the matching raises of the last filing day, or of up to 30 filing days if you ask. Every later run returns only raises it has not delivered before, because the Actor remembers what it sent in a key-value store tied to your filters. A run that finds nothing new writes one free row that says so. You pay per delivered raise. A Form D whose file cannot be read, a day SEC has not published yet and a run stopped early cost nothing for what they could not deliver.

The Actor reads SEC's daily index file and each filing's XML, never HTML pages. It names itself and a contact address in every request, as SEC asks, and sends at most 5 requests a second. It collects nothing about individuals: the related persons, sales agents and signer of a Form D, and the issuer's street address and phone, are left out of every row.

Why use SEC Form D Feed?

SEC lists every Form D in its daily index on the evening of the day it is filed: about 200 new ones and 80 to 160 amendments on a normal weekday. Finding the ones that matter means opening each filing, because the daily index gives only the form type, the company name and a file path. This Actor opens them for you, applies your filters, and keeps the rows you can sort and export.

What you get:

• Only new raises. The first run reads the latest filing day by default, up to 30. After that each run delivers what is new since the run before, and a raise is never delivered or charged twice for the same filters.
• Filters on the facts of the offering. Industry group or a whole sector heading, issuer location (EDGAR code, state or country name, or all of the US), offering amount range, exemption (Rule 504, 506(b), 506(c), 4(a)(5), 3(c)(1), 3(c)(7)), funds included, excluded or alone, and amendments on or off.
• Clean company-level rows. Flat fields with numbers as numbers, the sector heading next to the industry group, a flag for pooled funds, the exemptions as codes and as one line of text, and links to the filing on sec.gov.
• Clear statuses. ok, unparsed, failed, skipped or no-new-raises, each with a reason in a sentence. Only ok rows are charged.
• Fair use of SEC. A declared User-Agent, at most 5 requests a second, a wait on HTTP 429 and a full stop after two HTTP 403 answers in a row.

Each claim above has a test behind it:

What you get	How it works	The test that backs it
Only new raises, never charged twice	Delivered accession numbers are kept per filing day in a named key-value store. A later run on the same filters skips them. A run that restarts reads its own rows first, so a raise written just before a crash is not sent again. The memory is written one save at a time, so a slow write cannot land over a newer one.	"the prefill delivers the Technology raises of the latest filing day, then a second run delivers and charges nothing", "B2 a crash after a row is written but before the memory is saved delivers and charges nothing twice", "P3 a memory write still on its way when the day ends leaves no filing out, and the next run delivers and charges nothing", "P1 on migrating the run saves its memory and summary, and the restarted run repeats nothing", and the live test "live: the latest filing day, five raises at a time, and a second run on the same memory repeats nothing" (13 Oct 2026).
A Form D is fetched once per memory	Filings that did not match are remembered too, so a repeat run downloads nothing it has already judged. With a named memory, a change of filters reads again only the filings that did not match.	"a named memory keeps deliveries across a filter change and reads again only what did not match", and the second run in the prefill test, which sends 2 requests.
Filters that work on the filing itself	Each new Form D is parsed and checked against every filter you set. Amendments are dropped from the daily index before any download when you leave them off.	"filters together: US operating companies raising at least $5M under 506(b)", "a country covers its provinces: Canada finds the Alberta raise and the British Columbia amendment", "funds only: the pooled funds, with their indefinite amounts and fund types", "amendments are off by default and cost no request".
Company facts, with no people in them	The related persons, sales agents and signature are cut out of the XML before it is parsed, and the issuer's street, zip code and phone are never read.	"every recorded Form D but the cut one parses, and nothing about a person reaches the result", "person blocks are cut out before parsing, also with a namespace prefix". A live run over the 365 Form D and D/A filings of 9 Oct 2026 parsed every one.
No charge for what it could not read	A Form D whose file is broken comes back as unparsed and costs nothing. Five files in a row failing with server errors stop the run, free.	"no filters, two days, amendments on: every Form D of 8 and 9 Oct, newest day first, the broken one unparsed and free", "N6 five Form D files in a row failing with server errors stop the run; those five are delivered free and not remembered".
A spending cap that stops the run	Set a maximum cost per run, or a maximum number of raises. The run stops before it charges past it, and the raises it held back come in the next run.	"P6 the maximum cost per run stops delivery cleanly, and the next run delivers what was held back", "maxResults stops after that many raises; the next run delivers the rest, none twice".
Fair use of SEC	Requests start at least 210 ms apart, at most 3 at a time. A 429 is waited out. A 403 gets one retry after 10 seconds, then the run sends nothing more and lists what it did not reach. SEC's answer for a file that does not exist yet is told apart from a refusal.	"N3 a refusal on one file and again on its retry stops every request to SEC; what was not reached is skipped, free", "N4 a 429 is waited out and the day is still read", "SEC's missing-file answer (403 with an AccessDenied XML body) is never taken for a refusal", "requests overlap when SEC is slow, and their starts still keep the gap".

Plus what the Apify platform adds around it:

• API access. Start runs and read results with the Apify API or the JavaScript and Python clients.
• Scheduling. Run it every weekday morning and get only the new raises each time.
• Integrations. Send new rows to Make, Zapier, Google Sheets, Slack or any webhook.
• Monitoring. Run history, logs and alerts for failed runs.

Typical uses are a morning list of new raises in one sector for a sales or partnerships team, deal flow for an investor who follows a region or a stage, a record of new fund launches for a fund administrator or a researcher, and a news desk that wants every large raise in its state.

What data can SEC Form D Feed extract?

Each new Form D that matches becomes one row in the dataset. The most useful fields:

Field	Type	What it holds
status	string	ok, unparsed, failed, skipped or no-new-raises.
filingDate, form, isAmendment	string, string, boolean	The filing date, D or D/A, and whether it amends an earlier filing.
accessionNumber, previousAccessionNumber	string	EDGAR's number for the filing, and for an amendment the filing it amends.
cik, issuerName, entityType	string	SEC's 10-digit number for the issuer, its name and its legal form.
jurisdictionOfIncorporation, yearOfIncorporation, incorporatedWithinFiveYears	string, number, boolean	Where and when the issuer was formed.
issuerCity, issuerStateOrCountry, issuerStateOrCountryName	string	The city, the EDGAR code (CA, NY, A0 for Alberta) and its name. Street and phone are left out.
industrySector, industryGroup, isPooledInvestmentFund, investmentFundType	string, string, boolean, string	Form D item 4, with the heading the group sits under.
revenueRange, netAssetValueRange	string	Form D item 5, as the filer chose it, such as "Decline to Disclose".
exemptionCodes, exemptionsText	array, string	Item 6: codes such as 06b and 3C.7, and their titles as one line.
dateOfFirstSale, firstSaleYetToOccur, offeringLastsMoreThanOneYear	string, boolean, boolean	Timing of the offering.
securityTypes, isBusinessCombination	array, boolean	What is offered.
totalOfferingAmount, totalAmountSold, totalRemaining, minimumInvestment	number	Amounts in US dollars. An amount the filer marked as indefinite is empty, and totalOfferingAmountIndefinite or totalRemainingIndefinite is true.
totalInvestors, hasNonAccreditedInvestors, nonAccreditedInvestors	number, boolean, number	Investor counts.
salesCommissions, findersFees	number	Fees in US dollars.
filingIndexUrl, formDUrl, xmlUrl	string	Links to the filing's index page, the readable Form D and its XML on sec.gov.
error, errorCode	string	Why a row is not ok, as a sentence and as a short code.
stateStore	string	The name of the key-value store that remembers what these filters have received.

The Overview view shows the issuer, industry, place, amounts and links. The Offering terms view shows the legal form, exemptions, securities, minimum investment and investors.

Every row that is not ok carries one of these codes in errorCode, so you can count rows by reason without reading the sentence. The sentence in error can be reworded in a later version. The code stays.

errorCode	Meaning
parse-failed	The Form D file could not be read. The filing is delivered with the index facts only, free, and not sent again.
details-missing	SEC has no Form D file for the filing. The filing is delivered with the index facts only, free.
details-unavailable	The Form D file could not be fetched this time. The filing is delivered free and comes again, in full, in the next run.
charge-limit	The run reached your maximum cost per run.
max-results	The run reached your maximum number of raises per run.
run-time-limit	The run reached its time limit.
repeated-failures	Five Form D files in a row failed with a server or network error, so the run stopped.
aborted	The run was stopped.
sec-blocked	SEC refused two requests in a row (HTTP 403), so the run sent nothing more.
not-found	SEC lists a daily index file but does not serve it yet.
no-index	SEC lists no daily index file for this quarter or the two before it.
rate-limited	SEC kept answering "too many requests" (HTTP 429) after three waits.
server-error, http-error	SEC answered with an error status.
network-error, timeout	SEC could not be reached, or did not answer within 30 seconds.
too-large, bad-response, unexpected-redirect	SEC sent a file over 50 MB, a file the Actor could not read, or a redirect to another site.
no-new-raises	The one row a run writes when nothing it read was new.
other	Any other reason. The sentence in error says what happened.

How to get new Form D raises every day

1. Open the Actor in Apify Console and select the Input tab.
2. The form is prefilled with the Technology heading and 1 filing day, so you can press Start to see a result straight away. On 13 Oct 2026 that run read the 207 new Form D filings of 9 Oct and returned 19 Technology raises in 75 seconds.
3. Set your filters under Filters: industry groups, issuer locations, the amount range, exemptions, pooled funds and amendments. Every filter is optional. With none set, you get every new Form D.
4. Press Start. A filing day takes about 75 seconds for new filings and about 130 seconds with amendments, whatever the filters, because every new Form D of the day is opened once.
5. Open the Output tab for the table, or the Offering terms view. Export it as JSON, CSV or Excel.
6. To get only new raises from then on, create a schedule with the same input, for example every weekday at 8:00 New York time, and set Filing days to read to 2.

To run it from code, send the same input to the Actor through the API:

{
    "lookbackDays": 2,
    "industryGroups": ["Health Care", "Technology"],
    "issuerLocations": ["US"],
    "minOfferingAmount": 1000000,
    "pooledFunds": "exclude"
}

How to send new Form D raises to Slack or Google Sheets (Make, Zapier, no code)

Each scheduled run holds only the raises that are new since the last run, so you can pass every run's results straight on.

Slack, built in. On the Actor's Integrations tab, add Slack, connect your workspace, pick a channel and choose the event "Run succeeded". Each finished run posts a message with a link to its results.

Google Sheets with Make.com.

1. In Make, create a scenario and add the Apify module that watches for finished Actor runs, set to this Actor.
2. Add the Apify module that gets dataset items, and map the run's default dataset ID.
3. Add Google Sheets "Add a Row" and map the fields you want, for example issuerName, totalOfferingAmount, industryGroup, issuerStateOrCountry and filingIndexUrl.
4. Optional: add a filter so only raises over an amount you choose, such as $5,000,000, reach the sheet.

Google Sheets or Slack with Zapier. Use the Apify trigger for a finished Actor run, then the Apify step that fetches dataset items, then a Google Sheets "Create Spreadsheet Row" or a Slack "Send Channel Message" action. A Zapier filter step works the same way as the Make filter.

Your own code. Add a webhook on the Integrations tab for the event "Run succeeded", and read the dataset from the URL in the payload.

Set the schedule first (see the steps above), so that each run, and each message or row, covers one new filing day.

How much does it cost to get Form D raises?

You pay per new raise delivered, and the Apify platform usage for the run is included. A raise costs $0.02 on the Free and Bronze plans, so 1,000 raises cost $20.

Event	When it is charged	Price
raise	One new raise delivered with status ok	$0.02 (Free, Bronze), $0.018 (Silver), $0.016 (Gold)
Actor start	Once per run, scaled by memory (Apify standard event)	$0.00005 per GB of memory

Rows with the status unparsed, failed, skipped or no-new-raises cost nothing, and a raise delivered by an earlier run for the same filters is never charged again. Filings that do not match your filters are read but never charged. You can cap a run with the Maximum cost per run setting or with maxResults, and the Actor stops cleanly at that limit.

How much does one raise cost?

One raise costs $0.02 on the Free and Bronze plans, $0.018 on Silver and $0.016 on Gold. A run adds a start fee of about $0.0000125 at the default memory of 256 MB. The price already includes the platform usage, so there is no second bill for compute. As a guide from the filings of 8 and 9 Oct 2026, a month of 21 filing days brings about 400 Technology raises ($8), about 40 raises of $5 million or more by health care companies ($0.84), or about 4,350 new Form D filings of every kind ($87).

How do I keep a run within budget?

Set Maximum cost per run when you start it or in the schedule, or set Maximum raises per run (maxResults). The run stops before it would charge past that amount. The raises it did not deliver get one skipped row per filing day with the code charge-limit or max-results, they stay out of the memory, and the next run delivers them while their day is inside the lookback. A first run with a long lookback can bring many raises at once, so start with 1 or 2 filing days.

What does a scheduled run cost when nothing is new?

Only the start fee, about $0.0000125 at 256 MB. SEC publishes each day's index once, at about 10 pm New York time, so a run between two publications finds nothing new, writes one no-new-raises row and charges nothing for it.

Input

Open the Input tab to see every setting with a short description. Every field is optional. The form has three groups:

• Filing days: lookbackDays, 1 by default, up to 30.
• Filters: industryGroups, issuerLocations, minOfferingAmount, maxOfferingAmount, exemptions, pooledFunds (include by default, or exclude or only) and includeAmendments (off by default).
• Limits, memory and contact: maxResults, stateStoreName and contactEmail.

lookbackDays counts filing days: weekdays on which EDGAR took filings and SEC has published the daily index. 1 is the latest such day, whatever weekday you run on, and 30 is about six weeks. Weekends and SEC holidays have no index, so they are never counted and cost nothing.

industryGroups takes the groups of Form D item 4, such as Biotechnology, Other Technology or Pooled Investment Fund. A heading with several groups, such as Health Care or Technology, covers all of them. issuerLocations takes EDGAR's two-letter codes (CA, NY, TX, A0 for Alberta), names as Form D writes them (California, Cayman Islands), a country that covers its provinces (Canada) or US for every state, Washington DC, Puerto Rico, the US Virgin Islands and Guam. The location is the issuer's principal place of business. minOfferingAmount and maxOfferingAmount are in US dollars and compare with the total offering amount. An offering marked Indefinite has no amount, so it is left out whenever you set either one. exemptions keeps raises that claim at least one of the codes you pick.

The memory of what was delivered is named after your filters. The same filters give the same memory in any order or spelling, so a schedule just works, and changed filters start a new memory. To keep one memory while you change filters, set stateStoreName to a name of your own, such as my-raises. Delivered raises are then never repeated, and the filings that did not match before are read again under the new filters.

contactEmail is optional. SEC asks every automated tool to name a contact in its requests. Leave it empty to use the Actor developer's address, or give your own if you want SEC to reach you about your runs. It goes to SEC in a request header only and is not stored in the output.

Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A run also writes a SUMMARY record to its key-value store with the counts of filing days read, Form D filings considered, checked, delivered and not matching (with the filter each failed), the charged raises, the requests sent to SEC and one line per filing day. Filings that do not match get no row: they are counted in SUMMARY. A filing day that could not be read gets a failed row, and work held back gets a skipped row with the reason, also when the run stops early at the cost cap, after SEC refused twice or near the time limit. A run in which no filing day could be read ends with the status Failed and the most common reason in its message, and the rows stay in the dataset.

A new raise and the row of a run with nothing new look like this:

[
    {
        "status": "ok",
        "errorCode": null,
        "error": null,
        "filingDate": "2026-10-09",
        "form": "D",
        "isAmendment": false,
        "accessionNumber": "0002156610-26-000001",
        "previousAccessionNumber": null,
        "cik": "0002156610",
        "issuerName": "Athanor Compute, Inc.",
        "entityType": "Corporation",
        "jurisdictionOfIncorporation": "DELAWARE",
        "yearOfIncorporation": 2026,
        "incorporatedWithinFiveYears": true,
        "yetToBeFormed": null,
        "issuerCity": "SAN FRANCISCO",
        "issuerStateOrCountry": "CA",
        "issuerStateOrCountryName": "CALIFORNIA",
        "additionalIssuers": 0,
        "industrySector": "Technology",
        "industryGroup": "Other Technology",
        "isPooledInvestmentFund": false,
        "investmentFundType": null,
        "isInvestmentCompanyAct1940": null,
        "revenueRange": "Decline to Disclose",
        "netAssetValueRange": null,
        "exemptionCodes": ["06b"],
        "exemptionsText": "Rule 506(b)",
        "dateOfFirstSale": "2026-09-02",
        "firstSaleYetToOccur": false,
        "offeringLastsMoreThanOneYear": false,
        "securityTypes": ["Equity"],
        "otherSecurityDescription": null,
        "isBusinessCombination": false,
        "minimumInvestment": 0,
        "totalOfferingAmount": 150000000,
        "totalOfferingAmountIndefinite": false,
        "totalAmountSold": 124999998,
        "totalRemaining": 25000002,
        "totalRemainingIndefinite": false,
        "hasNonAccreditedInvestors": false,
        "nonAccreditedInvestors": null,
        "totalInvestors": 8,
        "salesCommissions": 0,
        "findersFees": 0,
        "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/2156610/000215661026000001/0002156610-26-000001-index.htm",
        "formDUrl": "https://www.sec.gov/Archives/edgar/data/2156610/000215661026000001/xslFormDX01/primary_doc.xml",
        "xmlUrl": "https://www.sec.gov/Archives/edgar/data/2156610/000215661026000001/primary_doc.xml",
        "stateStore": "sec-form-d-feed-fe8b16c2c056f3b8cbfd",
        "deliveredAt": "2026-10-12T18:44:31.517Z"
    },
    {
        "status": "no-new-raises",
        "errorCode": "no-new-raises",
        "error": "No new raises. Read 1 filing day (2026-10-09): 207 Form D filings to consider, 19 delivered by earlier runs, 188 not matching your filters. Nothing was charged.",
        "filingDate": "2026-10-09",
        "form": null,
        "issuerName": null,
        "totalOfferingAmount": null
    }
]

The second row is shortened here. Every row carries every field, with null where a value does not apply, so exports keep the same columns.

Tips for faster runs and lower costs

• Keep amendments off unless you need them. They are dropped from the daily index before any download, so the run is shorter, and an amendment updates an earlier offering instead of reporting a new one.
• On a schedule, read 2 filing days. The second day costs no download once it is known, and a day SEC publishes late is still caught.
• A schedule once each weekday morning catches every raise. SEC writes each day's index once, so more frequent runs find nothing new until the next evening.
• Use one input for one feed. Two schedules with the same filters share one memory and split the raises between them. Two schedules with different filters each open every new Form D of the day.
• For a backfill, raise lookbackDays for one run, then lower it again. On 9 Oct 2026 filings a filing day took about 75 seconds for new filings, so 30 filing days need about 40 minutes, or about 65 with amendments. Give such a run a timeout of 90 minutes or more. A run that reaches its limit lists what it did not finish as skipped, and the next run continues.
• Set stateStoreName before you start editing filters you run on a schedule, so the memory carries over.

FAQ, disclaimers and support

Is it legal to collect data from SEC EDGAR?

EDGAR filings are public records, and SEC publishes the daily index and the filings' XML for automated use. SEC asks automated tools to declare who they are and to stay under 10 requests a second. The Actor declares itself in every request and stays under 5. How you may use what you collect depends on your purpose and your country, so check that for your use case. This is general information, not legal advice.

Is this an official SEC tool?

No. The Actor is an independent tool. It is not made, endorsed or checked by the U.S. Securities and Exchange Commission. The data comes as filed: if a filer made a mistake, the row repeats it. A Form D is a notice of an exempt offering, filed by the issuer itself. Check the filing on sec.gov before you act on it.

Is personal data involved?

The Actor is built to collect company facts only. From a Form D it reads the issuer and the offering, and it cuts the related persons (executive officers, directors and promoters), the sales agents and the signer out of the file before it is parsed. The issuer's street, zip code and phone are never read. Some fields can still name people: a company, a trust or a fund can carry a founder's name, and a small issuer's city can be where its owner lives. Under the GDPR and similar laws you are the controller of what you collect, so keep and use it for a lawful reason.

What is a filing day, and why did my run read Friday on a Monday?

A filing day is a day SEC has published a daily index for. SEC writes it at about 10 pm New York time on the day itself, and there is none for weekends and SEC holidays. A run on Monday morning therefore reads Friday's filings as its latest day, and a run on Monday evening after 10 pm New York time reads Monday's.

Why did I not get a raise I can see on EDGAR?

Check five things: the filing is a Form D (or a D/A with Include amendments on), its filing day is inside the lookback, it passes every filter you set (the notMatchingBy counts in SUMMARY say which filter stopped how many), it was not already delivered for these filters by an earlier run, and SEC has published the day's index. An offering marked Indefinite fails any amount filter. The location is the issuer's principal place of business, which can differ from its state of incorporation.

How does the Actor know what is new, and how do I start over?

After each run it keeps the accession numbers of the filings it delivered, and of the filings it read that did not match, in a named key-value store listed in each row as stateStore. The next run with the same filters skips both. To start over, delete that store under Storage in Console, or set a new stateStoreName. The memory forgets filing days older than 60 days, which no lookback can reach.

What happens when SEC limits the requests?

A "too many requests" answer (HTTP 429) is waited out, for as long as SEC's Retry-After header says and at most a minute, up to three times, and every request waits with it. A refusal (HTTP 403) gets one retry after 10 seconds. A second refusal stops all requests for the rest of the run, because SEC limits a busy address for a while. The filings and days the run did not reach get a skipped row with the code sec-blocked, nothing is charged for them, and the next run reads them.

What does unparsed mean?

The filing is new and delivered with the facts from the daily index (form, date, company name, CIK and links), but its Form D file could not be read, so it could not be checked against your filters and its offering fields are empty. The row is not charged. When the cause is passing (details-unavailable), the next run reads the filing again and delivers it in full if it matches. When the file itself is broken (parse-failed), the filing is not sent again.

What happens when a run reaches its time limit?

The Actor reads the time limit of the run from the platform and starts no new download in the last 30 seconds. The filings and days it did not reach get a skipped row with the code run-time-limit, nothing is charged for them, and the next run reads them while they are inside the lookback.

Can I send new raises to Slack, email or a spreadsheet?

Yes. Use Apify schedules for the runs, and integrations or webhooks to pass each run's dataset to Make, Zapier, Google Sheets, Slack or your own endpoint. Since each run holds only new raises, the dataset of a run is the alert.

What if something looks wrong?

Open the Issues tab on the Actor page and describe your input and what you expected. A run link helps. Issues are answered within two days.

Other Actors by the same developer

• SEC EDGAR Filing Monitor: new SEC filings for the tickers or CIKs you watch.
• SEC XBRL Fundamentals: revenue, EPS, cash flow and other reported figures per company and period, from SEC XBRL filings.
• UK Company Check: Companies House status, outstanding charges and risk flags for UK companies, or a list of newly registered ones.
• US Trademark Status and Watch: USPTO status and upcoming deadlines for US trademarks, and what changed since your last run for marks you watch.
• New Scholarly Papers Watch: papers new since your last run for the keywords, ORCID authors, journals, funders or DOIs you watch, from Crossref.
• Full Page Website Screenshot: full-page PNG or JPEG screenshots, including pages that load content as you scroll.