# Startup Funding Rounds: SEC Form D Feed (`lone_rachis/sec-form-d-raises-feed`) Actor

Startup funding rounds and private raises from SEC Form D, every filing day: who raised, how much, industry, state and exemption, with the amounts parsed. Filter by amount, industry and location; each scheduled run returns only new raises.

- **URL**: https://apify.com/lone_rachis/sec-form-d-raises-feed.md
- **Developed by:** [Kesav Kumar Jayakumar](https://apify.com/lone_rachis) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $16.00 / 1,000 raises

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

### 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:

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

```json
[
    {
        "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](https://apify.com/lone_rachis/sec-edgar-filing-monitor): new SEC filings for the tickers or CIKs you watch.
- [SEC XBRL Fundamentals](https://apify.com/lone_rachis/sec-xbrl-fundamentals): revenue, EPS, cash flow and other reported figures per company and period, from SEC XBRL filings.
- [UK Company Check](https://apify.com/lone_rachis/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](https://apify.com/lone_rachis/us-trademark-status-watch): USPTO status and upcoming deadlines for US trademarks, and what changed since your last run for marks you watch.
- [New Scholarly Papers Watch](https://apify.com/lone_rachis/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](https://apify.com/lone_rachis/full-page-website-screenshot): full-page PNG or JPEG screenshots, including pages that load content as you scroll.

# Actor input Schema

## `lookbackDays` (type: `integer`):

How many of SEC's most recent filing days to read, counted in 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; 5 is about a week; 30 (the maximum) is about six weeks. A day's index appears at about 10 pm New York time. A day holds about 200 new Form D filings and 80 to 160 amendments, and the run reads each one it has not judged before, under 5 a second. Measured on 9 Oct 2026 filings: 1 day took 75 seconds for new filings and 130 seconds with amendments, so a first run over 30 days takes about 40 minutes, or about 65 with amendments. Later runs on the same filters read only the days they have not seen. On a schedule, use 2 or more, so a day SEC publishes late is never skipped.

## `industryGroups` (type: `array`):

Keep raises whose Form D industry group (item 4 of the form) is one of these. A heading such as Technology or Health Care covers every group under it. Leave empty for every industry. Pooled Investment Fund is the group hedge, private equity and venture funds tick; the Pooled investment funds setting below handles them too.

## `issuerLocations` (type: `array`):

Keep raises whose issuer address is in one of these places, one per line. Use the two-letter code EDGAR uses (CA, NY, TX; A0 for Alberta), a full name as Form D writes it (California, Cayman Islands), a country name that covers its provinces (Canada), or US for every US state, Washington DC, Puerto Rico, the US Virgin Islands and Guam. The address is the issuer's principal place of business, not its state of incorporation. Leave empty for anywhere.

## `minOfferingAmount` (type: `integer`):

Keep raises whose total offering amount is at least this many US dollars. An offering marked Indefinite on the form has no amount, so it is left out whenever you set a minimum or a maximum. Leave empty for no lower limit.

## `maxOfferingAmount` (type: `integer`):

Keep raises whose total offering amount is at most this many US dollars. Leave empty for no upper limit.

## `exemptions` (type: `array`):

Keep raises that claim at least one of these exemptions (item 6 of Form D). 506(b) is the private placement most issuers use, 506(c) allows general solicitation, and 3(c)(1) and 3(c)(7) are the fund exclusions. Leave empty for any exemption.

## `pooledFunds` (type: `string`):

Whether offerings by pooled investment funds (hedge, private equity, venture and other funds, industry group Pooled Investment Fund) count. About 6 in 10 new Form D filings are funds (123 of 207 on 9 Oct 2026). include: funds count like any issuer. exclude: only operating companies and other issuers. only: funds and nothing else.

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

Also return amended Form D filings (D/A). An amendment updates an earlier offering, often the amount sold or the yearly renewal, so it is not a new raise. Each amendment is its own filing and is delivered and charged once like any other. Off by default; amendments that are not wanted cost no request, because the daily index already names the form.

## `maxResults` (type: `integer`):

Optional. Stop after delivering this many raises. The ones not reached stay out of the memory, and the next run delivers them while their filing day is still inside the lookback. Leave empty for no limit, and use Maximum cost per run to cap spending.

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

Optional. Name of the key-value store that remembers which filings were delivered and which did not match. Leave it empty and the Actor makes a name from your filters, so the same filters always use the same memory and changed filters start fresh. Set a name to keep one memory while you change filters: delivered raises are never repeated, and filings that did not match before are read again under the new filters. Lower-case letters, digits and hyphens, at most 63 characters. Delete the store in Storage to start again.

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

Optional. SEC asks every automated tool to name a contact in the User-Agent header of its requests. Leave it empty to use the Actor developer's address. Give your own if you want SEC to reach you about your runs. It is sent to SEC only, in that header, and is not stored in the output.

## Actor input object example

```json
{
  "lookbackDays": 1,
  "industryGroups": [
    "Technology"
  ],
  "issuerLocations": [],
  "exemptions": [],
  "pooledFunds": "include",
  "includeAmendments": false
}
```

# Actor output Schema

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

Dataset with one row per new Form D raise: status, issuer, industry, location, exemptions, amounts offered and sold, investors, dates and links.

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

Counts of filing days read, Form D filings considered, checked, delivered and not matching, the charged raises, the requests sent to SEC and the memory store used.

# 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 = {
    "lookbackDays": 1,
    "industryGroups": [
        "Technology"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lone_rachis/sec-form-d-raises-feed").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 = {
    "lookbackDays": 1,
    "industryGroups": ["Technology"],
}

# Run the Actor and wait for it to finish
run = client.actor("lone_rachis/sec-form-d-raises-feed").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 '{
  "lookbackDays": 1,
  "industryGroups": [
    "Technology"
  ]
}' |
apify call lone_rachis/sec-form-d-raises-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lone_rachis/sec-form-d-raises-feed"
        }
    }
}
```

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/CFt1RTM5EFe3yKG8m/builds/pVN9eDv5IisQhaULw/openapi.json