# Private Offering Notice Feed (`amplelabs/private-offering-notice-feed`) Actor

New Form D private offering notices from SEC EDGAR public filings. Add Form D/A amendments with formTypes. Filter by industry, state, offering size and exemption.

- **URL**: https://apify.com/amplelabs/private-offering-notice-feed.md
- **Developed by:** [Ample Labs](https://apify.com/amplelabs) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 new filings

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/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

## Private Offering Notice Feed

Incremental feed of new Regulation D offering notices (Form D; add Form D/A amendments with formTypes). Each run downloads the filings itself from EDGAR and writes them to your Apify dataset.

### 1. What it does

The Actor reads the SEC daily form index for each business day since your cursor, keeps the Form D rows (and Form D/A rows if formTypes includes D/A), downloads each new primary XML, and pushes the filings that match your filters.

#### What you get

- One row per Form D accession, or per Form D/A too if you add D/A to formTypes, with issuer name, CIK, state, industry group, exemption codes, offering amount, amount sold, date of first sale, and links to the filing and its XML.
- Each matching filing is delivered once per state key. The delivered list keeps only the newest quarter's filings; filings from an older quarter, for example in a backfill, are not remembered.

It remembers what it has already delivered. Each charged filing is written to state before the run continues, and that state is saved again if the run is blocked, fails, or the platform migrates or aborts it. Once a week it can report filings that disappeared from the current quarter's index.

### 2. Source and attribution

The data comes from EDGAR on sec.gov. The SEC's [privacy page](https://www.sec.gov/privacy) says: "Information presented on sec.gov is considered public information and may be copied or further distributed by users of the web site without the SEC's permission. Please consider appropriate citation to the SEC as the source."

Every filing and every removal tombstone includes:

`Source: U.S. Securities and Exchange Commission, EDGAR (sec.gov).`

The same page says: "'SEC,' the EDGAR logo, and the names EDGAR, EDGARLink, and EDGARLink Online are the SEC's registered trademarks. You may not use them in a trade name, trademark, or domain name of an SEC- or EDGAR-related business without a license from the SEC. You may refer in text to the existence of EDGAR and the EDGAR system without a license, so long as you are not creating the impression that your business is affiliated with or approved by the SEC."

Ample Labs is not affiliated with, endorsed by, or sponsored by the U.S. Securities and Exchange Commission. "SEC" and "EDGAR" are used only to describe the data source.

### 3. Quick start

Run it once a day, at an off-minute in the morning US Eastern time, for example 06:17. The daily indexes are updated at night, starting around 22:00 America/New_York, and EDGAR disseminates filings Monday through Friday.

Leave the dates empty. The first run reads the latest completed business day. If that day's index is not published yet, the first run steps back up to 5 business days and reads the newest day that has one. Later runs continue from the cursor saved for `stateKey`.

Give each schedule, and each different filter setup, its own `stateKey`. The default is `default`. Dedupe is stored per key, so two setups that share a key can hide filings from each other. Use `resetState` once if you want that key to start over, then turn it off.

Use one schedule and do not start a second run while one is still going. See section 8.

### 4. Inputs and exemption codes

| Input | Default | What it does |
|---|---|---|
| dateFrom | empty | Start of a backfill. Leave empty to continue from the cursor. One run scans at most `maxBackfillDays` business days (default 1, maximum 30). The same dates resume after the last finished day. Clear the dates when the backfill is done. |
| dateTo | empty | Last day to scan. Empty means the latest business day whose index should already be published. A span longer than `maxBackfillDays` finishes on later runs with the same dates. |
| formTypes | `D` | `D` is a new notice. `D/A` is an amendment. |
| industryGroups | empty | EDGAR industry group names, such as Biotechnology or Pooled Investment Fund. Empty keeps all. |
| excludePooledFunds | false | Drop industry group Pooled Investment Fund. |
| states | empty | Issuer state or country codes, such as CA or NY. |
| minAmountSold | empty | Minimum total amount sold, in dollars. |
| minTotalOffering | empty | Minimum total offering amount, in dollars. `Indefinite` passes. |
| exemptions | empty | Keep filings that use at least one of these codes. |
| firstSaleOnly | false | Keep only filings with a date of first sale. |
| includeRelatedPersonNames | false | Add related-person names, and sales-compensation recipient names and CRD numbers. Those may identify a person. The associated broker-dealer name and CRD are the firm's record and are included either way. |
| includeStreetAddress | false | Add the issuer street and phone. Personal data. |
| maxResults | 100 in the Console, 1000 if omitted | The Console form starts at 100. A call that leaves the field out still stops after 1000 pushed filings. The unfinished day resumes next run. |
| maxBackfillDays | 1 | Business days to scan this run. Default 1. Maximum 30. A longer range, or a cursor more than this many business days behind, is left for a later run. The run warns and does not scan the waiting days in one run. The status says how many days were scanned. |
| stateKey | `default` | Names the saved cursor. Use one key per schedule or filter setup. |
| resetState | false | Drop the saved cursor and delivered list for this key and start fresh. |

There is no input for request rate. The cap is fixed in the code.

Federal exemption codes are the item values in Form D XML technical specification §4.22:

| Exemption | Code |
|---|---|
| Rule 504(b)(1) (not (i), (ii), or (iii)) | `04` |
| Rule 504(b)(1)(i) | `04.1` |
| Rule 504(b)(1)(ii) | `04.2` |
| Rule 504(b)(1)(iii) | `04.3` |
| Rule 506(b) | `06b` |
| Rule 506(c) | `06c` |
| Securities Act §4(a)(5) | `4a5` |
| Investment Company Act §3(c) | `3C` |
| §3(c)(1), (2), (4), (5), (6), (7), (9), (10), (11), (12), (13), (14) | `3C.1`, `3C.2`, `3C.4`, `3C.5`, `3C.6`, `3C.7`, `3C.9`, `3C.10`, `3C.11`, `3C.12`, `3C.13`, `3C.14` |

Industry group names are the EDGAR `industryGroupType` values, including Agriculture, Commercial Banking, Insurance, Investing, Investment Banking, Pooled Investment Fund, Other Banking and Financial Services, Business Services, Coal Mining, Electric Utilities, Energy Conservation, Environmental Services, Oil and Gas, Other Energy, Biotechnology, Health Insurance, Hospitals and Physicians, Pharmaceuticals, Other Health Care, Manufacturing, Commercial, Construction, REITS and Finance, Residential, Other Real Estate, Retailing, Restaurants, Computers, Telecommunications, Other Technology, Airlines and Airports, Lodging and Conventions, Tourism and Travel Services, Other Travel, and Other.

### 5. Output dictionary

The Output tab lists every field. Personal-data fields stay off unless you turn them on.

| Field | What it is |
|---|---|
| accessionNumber | EDGAR accession number. This is the dedupe key. |
| issuerName | Issuer name as filed. |
| formType | `D` or `D/A`. |
| filedAt | Filing date, `YYYY-MM-DD`. |
| totalOfferingAmount | Dollars, or null when the offering is Indefinite (then `isIndefinite` is true). |
| isIndefinite | True when the filing gives the total offering amount as Indefinite. |
| federalExemptions | Exemption item codes. |
| issuerState | Issuer state or country code. |
| eventType | `new`, `backfill`, `removed`, or `no-new-filings`. |
| daysScanned | On the status row. Business days fully scanned, possibly empty. |
| cursorDate | On the status row. Cursor after the run, or null. |
| stopReason | On the status row. `completed`, `spending-limit`, `sec-blocked`, `index-not-ready`, or `time-margin`. |
| runAt | On the status row. Time the row was written. |

From 0.2.0, totalOfferingAmount and totalRemaining are a number or null. Indefinite offerings have isIndefinite true. Previously these fields could be the string Indefinite. Rows delivered before 0.2.0 keep the old shape.

A removal tombstone is free. It has the accession number, `removed`, the detection time, and the SEC attribution line. It has no personal-data fields. Filter it by keeping rows whose `eventType` is `new` or `backfill`.

When a run delivers no filings and no removal tombstones, it pushes one status row after state is saved. `eventType` is `no-new-filings`. The row is free. It is not a filing, it is not added to `delivered`, and it does not move the cursor. Filter it the same way you filter a `removed` tombstone, on `eventType`. A run that fails does not push this row.

Names, street, and phone are off by default. Broker-dealer firm name and CRD are included when the filing names a firm, and omitted when it says None. Recipient names and CRD numbers stay off unless `includeRelatedPersonNames` is on.

### 6. Incremental delivery and tombstones

State is stored in a named key-value store in your Apify account, `private-offering-notice-feed-state-<stateKey>`, under the record `FEED_STATE`. A new run does not get a new copy of that store. The run's own default key-value store is empty every time, so the cursor is not kept there.

- `cursorDate` is the last business day that was fully scanned.
- `delivered` is the accession numbers delivered in the current quarter for this `stateKey`. It is pruned when the quarter changes.
- `lastRemovalCheck` is the last time a removal check finished.

An accession already in `delivered` is not fetched or charged again. `delivered` is saved after every charged filing, and again if the run is blocked, fails, migrates, or aborts. The cursor moves forward only after a day is fully scanned. If the spending limit, the run timeout, or `maxResults` stops the run in the middle of a day, that day stays unfinished. Filings already charged stay in `delivered`.

A backfill stores its `dateFrom`, its `dateTo`, and the last day of that range that was fully scanned. The next run with those same dates starts the day after that finished day, so the run does not charge `day-scanned` again for a day it already finished. A different `dateFrom` or `dateTo` starts the new range from its first day. Rescanning days that overlap a range you already scanned charges `day-scanned` again. Filings already delivered from the newest quarter are not charged again; filings from older quarters are delivered and charged again. Clear the dates when you want the cursor to follow new days.

If less than 30 seconds remain before the platform run timeout (`ACTOR_TIMEOUT_AT`), the run saves its place and stops. Run the same input again to continue. Finished backfill days are not scanned or charged again. The platform run timeout stays 1 hour. A run that stops for that timeout resumes on the next run.

The removal check runs on the first run after Saturday 12:00 America/New_York, and at most once a week. It downloads `full-index/{year}/QTRn/form.idx` for the current quarter only and streams it. Accessions this stateKey has delivered, dated before that Saturday, and missing from the rebuilt index, become tombstones and are dropped from `delivered`.

If that download fails, the run still finishes. `removal-check` is not charged, and `lastRemovalCheck` stays where it was. The next try is on a later America/New_York calendar day, once that day, until the check succeeds. A second run on the same day does not download the index again.

Removals are detected only for filings delivered in the current calendar quarter. A filing delivered in one quarter and removed after the next quarter begins is not detected. Filings dated on or after that Saturday are left for the next weekly rebuild, because the Saturday index does not contain them yet. The SEC does not support partial downloads of the index, so older quarters are not diffed.

A 404 for a past business day is treated as a holiday with no filings. A 404 for the newest day leaves the cursor where it is, because that index may not be published yet.

On a first run, with no saved cursor and no `dateFrom`, a missing index is handled differently. The run steps back one business day at a time, up to 5 business days, until it finds a day that has an index. It scans that day, sets the cursor there, and logs the days it skipped. Those skipped days are not charged `day-scanned`. A cursor run or a date range does not step back. If none of the 5 days has an index, the run pushes the status row with `stopReason` `index-not-ready` and leaves the cursor empty.

### 7. Pricing

- $0.005 to start a run (`apify-actor-start`) (one start event per GB of memory; this Actor always uses one)
- $0.003 for each new filing pushed (`new-filing`)
- $0.005 for each business day scanned after the run's first day (`day-scanned`)
- $0.001 for the weekly removal check (`removal-check`), charged only when the check downloads the index

Each run needs a maximum cost of at least $0.01, enough for the start and one filing.

Tombstones are free. The `no-new-filings` status row is free. Saving a filing to the dataset does not add a separate charge. The first day in a run is not a `day-scanned` event. A three-day backfill therefore charges `day-scanned` twice. Days skipped while a first run looks for a published index are not charged.

Before each extra day, and before each filing download, the run checks how many of that event it can still charge. On a day that will be charged `day-scanned`, the filing check also requires that the filing price and the pending day price both fit in the remaining budget. If they do not, it stops before that work. The cursor stays on the last fully scanned day. Nothing that was pushed is left uncharged: the filing is pushed, then charged, then saved. The day charge happens after the cursor is saved. A later run does not fetch or charge an accession that was already saved.

Default memory is 256 MB. Maximum memory is 512 MB.

### 8. Fair-access design

The Actor calls sec.gov directly. It does not use a proxy and it does not rotate IP addresses.

- At most one request per second, and one request in flight.
- No input can raise that rate.
- Every request sends `User-Agent: Ample Labs support@haveample.com` and `Accept-Encoding: gzip, deflate`.
- On a 403 or 429, the run stops, waits at least 10 minutes, and retries once at 0.5 requests per second. A second 403 or 429 ends the run. The cursor is not advanced for the in-progress day. The filing that failed is not pushed. Filings already charged are saved. A warning is written to the log and the status message.
- On a 5xx response or a timeout, the run waits 2 seconds, then 4 seconds, and stops after 3 tries. Filings already charged are saved before the run fails.
- Each run on the Apify platform waits a random 0 to 30 seconds before the first SEC request, so simultaneous runs do not all start together. Local runs skip that wait. Buyers cannot turn the wait off.
- Before the first SEC request, the run asks https://api.ipify.org for the egress IP and logs it once. If that lookup fails, the run continues.

Do not run more than one copy of this Actor at a time on an account. Apify does not give this Actor a way to see your other runs, so the one-run limit is a rule for how you schedule it, not a lock inside the run. Ten overlapping runs would be enough to reach the SEC's 10 requests per second guidance.

### 9. Privacy

The source is SEC EDGAR Form D. The filing can include the issuer's address and phone, and the names, roles, and addresses of executive officers, directors, and promoters.

Ample Labs does not store the output. The run executes in your Apify account. The dataset and the key-value store belong to you.

If "Share run data with developers" is on, your runs of public Actors are visible to the Actor's developer. That includes logs, input, and output storages (dataset, key-value store, and request queue). A run linked in an Actor issue is shared with the developer as well. The setting is described in Apify's [general resource access](https://docs.apify.com/account/collaboration/general-resource-access) page.

You decide whether to turn on names, street, and phone. They are off by default. Only issuer-level fields are on by default, and the issuer street and phone stay off with them. `recipientName` and `recipientCRDNumber` may identify a person and stay off unless `includeRelatedPersonNames` is on. `associatedBDName` and `associatedBDCRDNumber` are the broker-dealer firm's record, not personal data, and are included by default. The solicitation states and the count of recipients stay on.

If you process personal data of people in the European Economic Area, you are the controller. GDPR Article 14 requires a controller, in many cases, to tell people when their data did not come from them. Article 14(5)(b) says that duty does not apply where providing the information would be impossible or would involve a disproportionate effort. The official text is at the [EU Publications Office copy of Regulation (EU) 2016/679](https://publications.europa.eu/resource/cellar/3e485e15-11bd-11e6-ba9a-01aa75ed71a1.0006.01/DOC_1). Whether that exception fits your use is your decision. This section is not legal advice.

### 10. Lawful use

Do not use this feed for unsolicited mass messaging. The [Apify Acceptable Use Policy](https://docs.apify.com/legal/acceptable-use-policy) prohibits that.

If you email anyone using information from this feed, the CAN-SPAM Act, 15 U.S.C. 7704(a)(5), requires a clear identification that the message is an advertisement or solicitation, a working opt-out, and a valid physical postal address of the sender, unless you already have their prior affirmative consent for the identification requirement.

Form D data is taken from federal government records. The California Consumer Privacy Act, Civil Code §1798.140, excludes publicly available information, including information lawfully made available from federal, state, or local government records. That exclusion does not by itself make every later use lawful.

This is not legal advice.

### FAQ

**Do I pay again for a filing I already received?** Not under the same state key, if the filing is from the quarter the delivered list keeps. The list keeps one quarter: it moves to a newer quarter when a newer filing is delivered, or when the weekly removal check runs in a new calendar quarter. Filings from an older quarter are not remembered and are charged again if delivered again. A Form D/A is a separate filing. It is delivered only if formTypes includes D/A, and it is charged as a new filing.

**Why did I get a row with eventType no-new-filings?** The run found nothing new. It is free. Filter on `eventType` `new` or `backfill` to keep filings only.

**Can I get older filings?** Yes. Set Date from and Date to. Each extra day in a run costs $0.005.

**Are names and addresses included?** Not by default. Turn on `includeRelatedPersonNames` or `includeStreetAddress`. You are responsible for lawful use; see Privacy and Lawful use.

**Can I run several schedules?** Yes, one at a time, each with its own `stateKey`.

### 11. Support

Questions and takedown requests: support@haveample.com.

### 12. Changelog

#### 0.2.0

- From 0.2.0, totalOfferingAmount and totalRemaining are a number or null. Indefinite offerings have isIndefinite true. Previously these fields could be the string Indefinite. Rows delivered before 0.2.0 keep the old shape.

#### 0.1.8

- A run that delivers nothing pushes one free `no-new-filings` row after state is saved. Filter it on `eventType`, the same way you filter `removed`.
- A first run with no cursor and no dates steps back up to 5 business days when the latest index is missing. Skipped days are not charged.
- The Console prefill for `maxResults` is 100. A call that omits the field still uses 1000.

#### 0.1.7

- Add the dataset schema and the output schema. The Output tab lists every field.
- A run needs a maximum cost of at least $0.01, enough for the start and one filing.

#### 0.1.6

- Omit a broker-dealer name or CRD, and a recipient name or CRD, when the filing says None.
- The random start delay is at most 30,000 milliseconds. A draw of 0.999999 stays within that cap.

# Changelog

This Actor's version history is a separate document: https://apify.com/amplelabs/private-offering-notice-feed/changelog.md

# Actor input Schema

## `dateFrom` (type: `string`):

First filing date to scan, as YYYY-MM-DD. Leave empty to continue from the saved cursor. On the first run, the default is the latest business day whose nightly index should already be published. One run scans at most maxBackfillDays business days. The default is 1 and the maximum is 30. The same dateFrom and dateTo resume after the last finished day of that range. Clear both dates when the backfill is done.

## `dateTo` (type: `string`):

Last filing date to scan, as YYYY-MM-DD. Leave empty to stop at the latest business day whose nightly index should already be published (around 22:00 America/New_York). A span longer than maxBackfillDays (default 1, maximum 30) finishes on later runs. The status message says how many of those days this run scanned.

## `formTypes` (type: `array`):

Which notices to deliver. D is a new notice. D/A is an amendment. The default is new notices only. Days are still marked scanned when a filing is filtered out, so widening this later does not replay old days. Use Date from to backfill.

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

Keep filings whose EDGAR industryGroupType is in this list. Leave empty to keep every industry. Examples: Biotechnology, Other Real Estate, Pooled Investment Fund, Other Technology.

## `excludePooledFunds` (type: `boolean`):

Drop filings whose industry group is Pooled Investment Fund.

## `states` (type: `array`):

Keep filings whose issuer state or country code is in this list. Use EDGAR codes such as CA, NY, or DE. Matching is case-insensitive. Leave empty to keep every jurisdiction.

## `minAmountSold` (type: `integer`):

Keep filings whose total amount sold is at least this many dollars. Leave empty to apply no minimum.

## `minTotalOffering` (type: `integer`):

Keep filings whose total offering amount is at least this many dollars. An Indefinite offering is treated as large enough. Leave empty to apply no minimum.

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

Keep filings that claim at least one of these Form D item codes from technical specification section 4.22. Leave empty to keep every exemption.

## `firstSaleOnly` (type: `boolean`):

Keep only filings that report a date of first sale. Filings marked yet to occur are dropped.

## `includeRelatedPersonNames` (type: `boolean`):

Add related-person names, and sales-compensation recipient names and CRD numbers. Off by default. A recipient name or CRD may identify a person. The associated broker-dealer name and CRD are the firm's record and are included either way. The run log never includes names or CRD numbers.

## `includeStreetAddress` (type: `boolean`):

Add the issuer street address and phone number. Off by default. Both are personal data. Related-person street addresses are never included. The run log never includes streets or phone numbers.

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

Stop after this many filings have been pushed in the run. The Console form starts at 100. A call that omits this field still uses 1000. The day is left unfinished, so the next run continues with the filings that were not delivered. Removal notices do not count toward this limit.

## `maxBackfillDays` (type: `integer`):

Maximum number of business days to scan in this run. The default is 1. The maximum is 30. A longer date range, or a cursor more than that many business days behind, is not scanned in one run. The status message says how many days were scanned and how to continue. The first day is included in the run. Each later day is a day-scanned event, checked against the spending limit before the day starts and charged after the cursor is saved.

## `stateKey` (type: `string`):

Names the saved cursor for this schedule. The store is private-offering-notice-feed-state-<stateKey>. Use a different key for each filter set or schedule. Two runs that share a key share dedupe, so one can hide filings the other has not delivered. Lowercase letters, digits, and hyphens only, 1 to 28 characters. Default is default.

## `resetState` (type: `boolean`):

Ignore the saved cursor and delivered list and start this run as a first run. Turn it off again after that run, or the next run will also start over.

## Actor input object example

```json
{
  "formTypes": [
    "D"
  ],
  "maxResults": 100,
  "maxBackfillDays": 1,
  "stateKey": "default"
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset items. The Output tab uses the overview view.

# 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 = {
    "formTypes": [
        "D"
    ],
    "excludePooledFunds": false,
    "firstSaleOnly": false,
    "includeRelatedPersonNames": false,
    "includeStreetAddress": false,
    "maxResults": 100,
    "maxBackfillDays": 1,
    "stateKey": "default",
    "resetState": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("amplelabs/private-offering-notice-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 = {
    "formTypes": ["D"],
    "excludePooledFunds": False,
    "firstSaleOnly": False,
    "includeRelatedPersonNames": False,
    "includeStreetAddress": False,
    "maxResults": 100,
    "maxBackfillDays": 1,
    "stateKey": "default",
    "resetState": False,
}

# Run the Actor and wait for it to finish
run = client.actor("amplelabs/private-offering-notice-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 '{
  "formTypes": [
    "D"
  ],
  "excludePooledFunds": false,
  "firstSaleOnly": false,
  "includeRelatedPersonNames": false,
  "includeStreetAddress": false,
  "maxResults": 100,
  "maxBackfillDays": 1,
  "stateKey": "default",
  "resetState": false
}' |
apify call amplelabs/private-offering-notice-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,amplelabs/private-offering-notice-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/uWfuvJDenyBaAj05Y/builds/nvP5h1dkB7DwMnwx1/openapi.json