# SEC Form D Scraper (`axiomworks/sec-form-d-scraper`) Actor

Collect SEC Form D filings and return one row per filing with company name, filing date, industry, offering amounts, issuer address and related persons. Filter by date, EDGAR location, keyword, industry or minimum funding amount; pooled funds can be excluded.

- **URL**: https://apify.com/axiomworks/sec-form-d-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 results

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

## SEC Form D Funding Scraper

**Returns:** one row per SEC Form D filing with `companyName`, `fileDate`, `industryGroup`, `totalAmountSold`, `totalOfferingAmount`, `city`, `phone`, `relatedPersons`.
**Input:** `{"daysBack": 7, "states": ["CA"], "industryGroups": ["Other Technology"], "maxItems": 50}`
**Best for:** startup funding lead lists, tracking who raised money this week in a state or industry, investor and sales prospecting.

```json
{
    "companyName": "Arkea Bio Corp.",
    "fileDate": "2026-10-09",
    "industryGroup": "Other Technology",
    "totalAmountSold": 14999995,
    "totalNumberAlreadyInvested": 2,
    "salesCommissions": 0,
    "findersFees": 0,
    "sourceUrl": "https://www.sec.gov/Archives/edgar/data/2004801/000200480126000001/primary_doc.xml"
}
```

### What does SEC Form D Funding Scraper do?

SEC Form D Funding Scraper reads public SEC EDGAR Form D and D/A notices into structured filing records. Search by date, business location, industry and full-text keyword, then screen reported offering amounts, investor counts and federal exemption codes. No login or SEC API key is required.

The SEC Form D API alternative preserves issuer-reported amounts, public executive names, addresses and source links. Sales commissions and finder fees are included when disclosed, without extra requests. Each accession is a filing, not a unique company or a confirmed completed funding round. Related persons are officers, directors or promoters, not an investor list.

### What data can you get from SEC Form D filings?

Every record comes straight from the filing's `primary_doc.xml` on sec.gov plus the EDGAR search index. Amounts are numbers in US dollars, dates are `YYYY-MM-DD`.

| Field | Description |
|---|---|
| `id` | Same as `accessionNumber`, the stable record ID. |
| `accessionNumber` | SEC accession number that identifies this Form D filing. |
| `cik` | SEC Central Index Key of the issuer, 10 digits with leading zeros. |
| `companyName` | Issuer (company or fund) name as filed. |
| `formType` | 'D' for a new notice, 'D/A' for an amendment. |
| `fileDate` | Date the filing was accepted by EDGAR (YYYY-MM-DD). |
| `isAmendment` | True when the filing amends an earlier Form D. |
| `dateOfFirstSale` | Date the first securities were sold (YYYY-MM-DD); null when the first sale has yet to occur. |
| `industryGroup` | Form D industry group, e.g. Other Technology, Biotechnology, Pooled Investment Fund. |
| `investmentFundType` | Fund kind on pooled-fund filings: Venture Capital Fund, Private Equity Fund, Hedge Fund or Other Investment Fund. Null for operating companies, so always null while `excludePooledFunds` is on. |
| `entityType` | Legal form of the issuer, e.g. Corporation, Limited Liability Company, Limited Partnership. |
| `jurisdictionOfInc` | State or country where the issuer is incorporated. |
| `yearOfInc` | Year of incorporation when filed (only given for issuers formed within the last five years). |
| `revenueRange` | Revenue range as filed, e.g. 'No Revenues', a revenue band, or 'Decline to Disclose'. |
| `street1` | Issuer street address, line 1. |
| `street2` | Issuer street address, line 2. |
| `city` | Issuer city. |
| `stateOrCountry` | EDGAR code of the issuer's state or country, e.g. CA, NY, L3 (Israel). |
| `stateOrCountryDescription` | Name of the issuer's state or country. |
| `zipCode` | Issuer postal code. |
| `phone` | Issuer phone number as filed. |
| `totalOfferingAmount` | Total amount being offered in USD; null when the offering is 'Indefinite'. |
| `totalAmountSold` | Amount already sold (raised) in USD at filing time. |
| `salesCommissions` | Disclosed sales commissions in USD; null when absent or nonnumeric. |
| `findersFees` | Disclosed finder fees in USD; null when absent or nonnumeric. |
| `totalRemaining` | Amount still to be sold in USD; null when 'Indefinite'. |
| `minimumInvestmentAccepted` | Minimum investment accepted from any outside investor, USD. |
| `totalNumberAlreadyInvested` | Number of investors who have already invested. |
| `federalExemptions` | Exemptions claimed, e.g. 06b (Rule 506(b)), 06c (Rule 506(c)). |
| `securityTypes` | Types of securities offered, e.g. isEquityType, isDebtType. |
| `securityTypeLabels` | The same types as readable labels, e.g. Equity, Debt. |
| `signerName` | Name of the person who signed the filing. |
| `signerTitle` | Title of the signer, e.g. CEO. |
| `filingUrl` | Link to the filing index page on sec.gov. |
| `xmlUrl` | Link to the filing's primary_doc.xml with the full Form D data. |
| `sourceUrl` | URL the record was read from (the filing's primary_doc.xml). |
| `relatedPersons` | Executives, directors and promoters with name, relationships, city and state. |

Fields that a filing leaves empty are `null` (for example `street2`, `yearOfInc` for companies older than five years, or `dateOfFirstSale` when the first sale has yet to occur).

### How to use SEC Form D Funding Scraper

1. Open SEC Form D Funding Scraper in Apify Console and go to the Input tab.
2. Choose the filing dates: either set **Days back** (the default 7 returns the last week of filings) or set **startDate** and **endDate**.
3. Optionally add **States or countries** as EDGAR location codes, such as `CA`, `NY` or `TX`, or `L3` for Israel and `X0` for the United Kingdom. Each code is searched separately and the results are merged.
4. Optionally pick **Industry groups**, a **Minimum amount raised**, a **Minimum offering size** or a **Keyword** (EDGAR full-text search, usually a word from the company name such as `Therapeutics`).
5. Decide whether to include amendments (Form D/A) and pooled investment funds. By default you get only new Form D filings from operating companies.
6. Set **Maximum results** and click Start. When the run finishes, export the dataset as JSON, CSV, Excel, XML or HTML, or read it through the API.

Tips:

1. Filings are returned newest first. Many companies file several Form Ds on the same day and each accession number is its own row.
2. The location filter uses the business address EDGAR has on file for the company. In rare cases this differs from the issuer address inside the filing, so a row found with `CA` can show another state in `stateOrCountry`. The Actor keeps such rows rather than hiding them.
3. Industry, amount and pooled-fund filters can only be checked after each filing is downloaded. Narrow filters therefore check many filings per result. **Maximum filings to check** (default 1000) bounds that work; raise it together with the run timeout for long date ranges.

### Input

All fields are optional. With an empty input the Actor returns the newest Form D filings of the last 7 days from every location, without pooled funds and without amendments.

| Field | Type | Required | Description |
|---|---|---|---|
| `daysBack` | integer | No | Filings from the last N days, 0-3650, default 7. Ignored when `startDate` is set. |
| `startDate` | string | No | First filing date, `YYYY-MM-DD`. Empty = use `daysBack`. |
| `endDate` | string | No | Last filing date, `YYYY-MM-DD`. Default today (UTC). |
| `states` | array of strings | No | EDGAR location codes (`CA`, `NY`, `L3`...). One search per code, results merged. Empty = all. |
| `industryGroups` | array of strings | No | Form D industry groups to keep, e.g. `Other Technology`, `Biotechnology`, or a category such as `Health Care`. Empty = all. |
| `minAmountSold` | integer | No | Keep filings with `totalAmountSold` at least this (USD). |
| `minOfferingAmount` | integer | No | Keep filings with `totalOfferingAmount` at least this (USD); excludes "Indefinite" offerings. |
| `minInvestors` | integer | No | Minimum reported investor count, default 0 (disabled). |
| `federalExemptions` | array of strings | No | Match any exact SEC code, e.g. `06b` or `06c`; default empty (all). |
| `keyword` | string | No | EDGAR full-text search words, usually part of the company name, e.g. `Therapeutics`. |
| `includeAmendments` | boolean | No | Also return Form D/A amendments. Default false. |
| `excludePooledFunds` | boolean | No | Drop VC, PE and hedge fund filings (industry "Pooled Investment Fund"). Default true. |
| `maxItems` | integer | No | Maximum results across all locations, 1-10000, default 50. |
| `maxFilingsToCheck` | integer | No | Maximum filings downloaded and checked against the filters, default 1000. |
| `proxyConfiguration` | object | No | Optional proxy. Default none: SEC does not need one. |

Example input: technology offerings in New York in September and early October, amendments included.

```json
{
    "startDate": "2026-09-01",
    "endDate": "2026-10-10",
    "states": ["NY"],
    "industryGroups": ["Other Technology"],
    "minAmountSold": 1000000,
    "includeAmendments": true,
    "excludePooledFunds": true,
    "maxItems": 10
}
```

Example input: biotech and pharma companies with "Therapeutics" in the name, all locations.

```json
{
    "startDate": "2026-09-01",
    "endDate": "2026-10-15",
    "keyword": "Therapeutics",
    "industryGroups": ["Biotechnology", "Pharmaceuticals", "Other Health Care"],
    "maxItems": 10
}
```

Filters use AND between fields and OR within `federalExemptions`. For example, add `"minInvestors": 5, "federalExemptions": ["06b", "06c"]` to keep filings reporting at least five investors and either exemption. Codes are matched case-insensitively against the filing, not inferred from company names. An unknown code returns no matches. Investor and exemption filters run after XML downloads, so narrow searches may need a larger `maxFilingsToCheck`. The shared `maxItems` limit still applies across all locations.

### Output

Each filing is one item in the run's dataset. This record comes from a local run for Massachusetts filings from October 1–10, 2026, with `minInvestors: 2`, `federalExemptions: ["06B"]` and `maxItems: 1`:

```json
{
    "id": "0002004801-26-000001",
    "accessionNumber": "0002004801-26-000001",
    "cik": "0002004801",
    "companyName": "Arkea Bio Corp.",
    "formType": "D",
    "fileDate": "2026-10-09",
    "isAmendment": false,
    "dateOfFirstSale": "2026-09-28",
    "industryGroup": "Other Technology",
    "investmentFundType": null,
    "entityType": "Corporation",
    "jurisdictionOfInc": "DELAWARE",
    "yearOfInc": null,
    "revenueRange": "Decline to Disclose",
    "street1": "500 RUTHERFORD AVE",
    "street2": "STE. 302",
    "city": "CHARLESTOWN",
    "stateOrCountry": "MA",
    "stateOrCountryDescription": "MASSACHUSETTS",
    "zipCode": "02129",
    "phone": "(833) 275-3224",
    "totalOfferingAmount": 32999992,
    "totalAmountSold": 14999995,
    "totalRemaining": 17999997,
    "salesCommissions": 0,
    "findersFees": 0,
    "minimumInvestmentAccepted": 0,
    "totalNumberAlreadyInvested": 2,
    "federalExemptions": [
        "06b"
    ],
    "securityTypes": [
        "isEquityType"
    ],
    "relatedPersons": [
        {
            "firstName": "Frank",
            "middleName": null,
            "lastName": "Wooten",
            "relationships": [
                "Executive Officer",
                "Director"
            ],
            "city": "Charlestown",
            "stateOrCountry": "MA"
        },
        {
            "firstName": "Zachariah",
            "middleName": null,
            "lastName": "Serber",
            "relationships": [
                "Executive Officer"
            ],
            "city": "Charlestown",
            "stateOrCountry": "MA"
        },
        {
            "firstName": "Chris",
            "middleName": null,
            "lastName": "Rivest",
            "relationships": [
                "Director"
            ],
            "city": "Charlestown",
            "stateOrCountry": "MA"
        },
        {
            "firstName": "Wayne",
            "middleName": null,
            "lastName": "McNee",
            "relationships": [
                "Director"
            ],
            "city": "Charlestown",
            "stateOrCountry": "MA"
        }
    ],
    "signerName": "Frank Wooten",
    "signerTitle": "Chief Executive Officer",
    "filingUrl": "https://www.sec.gov/Archives/edgar/data/2004801/000200480126000001/0002004801-26-000001-index.htm",
    "xmlUrl": "https://www.sec.gov/Archives/edgar/data/2004801/000200480126000001/primary_doc.xml",
    "sourceUrl": "https://www.sec.gov/Archives/edgar/data/2004801/000200480126000001/primary_doc.xml"
}
```

Download the dataset as JSON, CSV, Excel, XML or HTML from the Storage tab, or fetch it with the API.

### How much does it cost to scrape SEC Form D filings?

SEC Form D Funding Scraper is charged per result: you pay only for the filings returned, and `maxItems` caps that number. Filings checked but filtered out (wrong industry, too small, pooled fund) are free. See the Pricing tab for the current price. If you set a maximum cost per run, the Actor stops cleanly there and says so in the status message.

### Use with AI agents (MCP)

Connect SEC Form D Funding Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/sec-form-d-scraper"
        }
    }
}
```

Example prompts:

1. "Find the technology startups in California that filed a Form D in the last 7 days and raised at least 1 million, and list their CEO and phone number."
2. "Which biotech companies with Therapeutics in their name filed SEC Form D since September 1? Show amount sold and offering size."
3. "Get this week's Form D filings from Texas and New York, excluding funds, and group them by industry."

### Integrations and API

Run SEC Form D Funding Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/sec-form-d-scraper").call(run_input={"daysBack": 7, "states": ["CA"], "maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyName"], item["totalAmountSold"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/sec-form-d-scraper').call({ daysBack: 7, states: ['CA'], maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~sec-form-d-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"daysBack": 7, "states": ["CA"], "maxItems": 50}'
```

On the Integrations tab you can send results to Google Sheets, Make, Zapier, n8n, Slack or a webhook. Schedule the Actor daily or weekly with `daysBack` set to 1 or 7 to get a running feed of new Form D filings.

### FAQ

**What do the fee fields mean?**
`salesCommissions` and `findersFees` copy the numeric amounts disclosed in the corresponding XML sections. Zero means an explicit zero; null means absent or nonnumeric. They do not prove payment, identify investors or establish the net proceeds of a completed financing.

**Why did my run return 0 results?**
EDGAR had no Form D filings for your dates, locations and keyword, or none matched your industry, amount or fund filters. The status message explains whether filters or source access prevented results. Widen dates, loosen filters or retry later. Blocked targets finish successfully with zero records rather than adding error rows. SEC request spacing also applies to retries; each attempt uses only the time remaining in its request deadline. Invalid dates still fail validation with a message explaining the accepted format.

**What are EDGAR location codes?**
US states use their two-letter postal codes (`CA`, `NY`, `TX`). Canadian provinces and other countries have EDGAR codes such as `A6` (Ontario), `A1` (British Columbia), `L3` (Israel), `X0` (United Kingdom), `2M` (Germany), `K7` (India), `U0` (Singapore) or `E9` (Cayman Islands). Common state and country names such as "California" or "Israel" are also accepted and converted.

**What is the difference between Form D and Form D/A?**
Form D/A amends an earlier Form D, for example with a new amount sold. Set `includeAmendments` to true to get both; `formType` tells them apart.

**Why are there pooled investment funds in Form D, and why are they excluded?**
VC, private equity and hedge funds file Form D too and make up a large share of filings. `excludePooledFunds` (on by default) drops them; turn it off to research funds, which also fills `investmentFundType`.

**Why is totalOfferingAmount null?**
Some issuers file their offering size as "Indefinite", usually funds. `totalOfferingAmount` and `totalRemaining` are then `null`, while `totalAmountSold` is still a number.

**Does it need a proxy?**
No. The SEC serves EDGAR to normal, rate-limited clients. The Actor sends a declared User-Agent and keeps to 5 requests per second, under the SEC's fair-access limit of 10. Rate-limited or failed requests are retried with backoff.

### Is it legal to scrape SEC Form D filings?

Form D notices are public records that the SEC publishes on EDGAR for anyone to read. This Actor reads only that public data, with no login, and follows the SEC's fair-access rules for automated tools. The filings contain names of company officers and directors; if you store or use personal data, you are responsible for doing so lawfully (for example under GDPR or CCPA). This is not legal advice.

SEC Form D Funding Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by the U.S. Securities and Exchange Commission (SEC) or EDGAR.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `daysBack` (type: `integer`):

Look at filings from the last N days (0-3650, default 7), counted back from endDate or today. Ignored when startDate is set. Example: 30 returns filings from the last month.

## `startDate` (type: `string`):

First filing date to include, YYYY-MM-DD, e.g. '2026-10-01'. Leave empty to use daysBack. If it is after endDate the two are swapped.

## `endDate` (type: `string`):

Last filing date to include, YYYY-MM-DD, e.g. '2026-10-10'. Default today (UTC). Works with startDate or daysBack.

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

EDGAR location codes of the company's business address, e.g. 'CA', 'NY', 'TX' for US states, or 'L3' (Israel), 'X0' (United Kingdom), 'A6' (Ontario). Each code is searched separately and results are merged; empty = all locations. A code with no filings returns 0 results.

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

Keep only filings whose Form D industry group matches, e.g. 'Other Technology', 'Biotechnology', 'Pharmaceuticals', 'Other Health Care', 'Business Services', 'Manufacturing', 'Computers', 'Oil and Gas'. Case-insensitive. A category name ('Technology', 'Health Care', 'Real Estate', 'Energy', 'Travel') selects all its groups. Empty = all industries. Checked on each filing after download.

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

Keep only filings that report at least this much already sold (totalAmountSold, USD), e.g. 1000000. Empty = no minimum.

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

Keep only filings whose total offering amount is at least this (USD), e.g. 5000000. Offerings filed as 'Indefinite' are excluded when this is set. Empty = no minimum.

## `keyword` (type: `string`):

Words to search in EDGAR full-text search, usually part of the company name, e.g. 'Therapeutics' or 'AI'. Empty = all filings. A keyword with no matches returns 0 results.

## `minInvestors` (type: `integer`):

Keep filings reporting at least this many investors (totalNumberAlreadyInvested), 0-1000000000. Default 0 disables this filter. Combined with other filters; may scan more filings.

## `federalExemptions` (type: `array`):

Keep filings claiming any listed SEC exemption code, e.g. 06b (Rule 506(b)) or 06c (Rule 506(c)). Case-insensitive exact codes, OR within this list and AND with other filters. Default \[] keeps all exemptions; no matches returns 0 results.

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

Also return Form D/A amendments, which update an earlier filing (e.g. a new amount sold). Default false: only new Form D filings.

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

Skip filings in the 'Pooled Investment Fund' industry group (venture capital, private equity and hedge funds raising from investors), so you get operating companies. Default true. Set false to include funds; investmentFundType is then filled for them.

## `maxItems` (type: `integer`):

Maximum number of filings to return across all locations, 1-10000, default 50. The run stops as soon as this many are saved, and you are charged only for results returned.

## `maxFilingsToCheck` (type: `integer`):

Upper bound on filings downloaded and checked against the industry and amount filters, 1-100000, default 1000. With narrow filters, raise it (and the run timeout) to search longer date ranges. The status message says when this limit stopped the run.

## `proxyConfiguration` (type: `object`):

Optional proxy for requests to sec.gov. Default no proxy (SEC does not block normal, rate-limited access). Blocked or rate-limited requests are retried with backoff, on a new proxy IP when a proxy is set.

## Actor input object example

```json
{
  "daysBack": 7,
  "states": [
    "CA"
  ],
  "industryGroups": [],
  "minInvestors": 0,
  "federalExemptions": [],
  "includeAmendments": false,
  "excludePooledFunds": true,
  "maxItems": 20,
  "maxFilingsToCheck": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "daysBack": 7,
    "states": [
        "CA"
    ],
    "excludePooledFunds": true,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/sec-form-d-scraper").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 = {
    "daysBack": 7,
    "states": ["CA"],
    "excludePooledFunds": True,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/sec-form-d-scraper").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 '{
  "daysBack": 7,
  "states": [
    "CA"
  ],
  "excludePooledFunds": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/sec-form-d-scraper --silent --output-dataset

```

## MCP server setup

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

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/d4flWRABlIabFQd69/builds/iFZrRGbuDyVpJdBtx/openapi.json