# SEC EDGAR Company Data Scraper (`scrapyspider/sec-gov-compony-data-scp`) Actor

Extract company data from SEC EDGAR — names, addresses, phone numbers, EIN, CIK, SIC codes, and filing details. Search by keyword, company name, ticker, state, filing type, or date range. Export as JSON, CSV, or Excel. No API key needed.

- **URL**: https://apify.com/scrapyspider/sec-gov-compony-data-scp.md
- **Developed by:** [ScrapySpider](https://apify.com/scrapyspider) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## SEC EDGAR Company Data Scraper

**Extract structured company filing data from the U.S. government's [SEC EDGAR database](https://www.sec.gov/edgar/search/) — no API key required, no sign-up needed.** Search for any business keyword (e.g. `construction`, `trucking`, `real estate`) across all 57 US states and territories, filter by entity type (LLC, INC, CORP, and 50+ more), date range, and filing type. For every match, the Actor navigates to the official SEC filing index page and extracts verified contact information, addresses, CIK number, EIN, SIC code, accession number, and more — all pushed directly to an Apify Dataset ready for export as **JSON, CSV, or Excel**.

### What does SEC EDGAR Company Data Scraper do?

**SEC EDGAR** (Electronic Data Gathering, Analysis, and Retrieval) is the U.S. Securities and Exchange Commission's official public portal for all company and individual filings submitted to the SEC. It is the single most authoritative source of verified business registration and corporate disclosure data in the United States — and it is completely free to access.

This Actor automates the [EDGAR Full-Text Search](https://efts.sec.gov/LATEST/search-index) interface. You provide one or more search keywords (company names, industry terms, tickers, or CIK numbers), optionally select specific states, date ranges, or filing types, and the Actor will:

1. Construct and navigate to the correct EDGAR search URL for every keyword × state combination
2. Paginate through all result pages (up to 10,000 results per search)
3. Visit each individual filing's index page on `sec.gov`
4. Extract **23 structured data fields** per record — legal name, addresses, phone, EIN, CIK, SIC code, SEC accession number, filing items, and all document links
5. Push every record to an Apify Dataset for instant download or API access

Runs on the Apify platform with full proxy support, scheduling, webhooks, Zapier/Make integrations, and monitoring — or locally with `apify run`.

***

### Why use SEC EDGAR Company Data Scraper?

#### Lead Generation at Scale

Find every company in a target industry that filed with the SEC in the last 30 days, 1 year, or 5 years. Filter by business type (LLC only, or INC only) and state. The output gives you a verified business name, physical address, phone number, and EIN — ready to import into any CRM.

#### Market Research & Competitive Intelligence

Track filings across construction, trucking, real estate, HVAC, insurance, fintech, or any other sector. Identify new market entrants, monitor growth activity, and benchmark against industry peers using SEC's own verified data.

#### Due Diligence & Background Checks

Before doing business with a company, verify their SEC registration details — CIK number, state of incorporation, SIC code, fiscal year end, and full filing history — directly from a U.S. government source.

#### Compliance Monitoring

Set up a scheduled Actor run to monitor when new companies in your industry or jurisdiction file with the SEC. Use `dateRange: "30d"` to get only the freshest filings each time.

#### Data Enrichment

Enrich your existing contact database with verified EINs, SIC codes, states of incorporation, and SEC accession numbers — data that is often expensive or unavailable from commercial providers.

***

### How to use SEC EDGAR Company Data Scraper

#### Option A — Quick Start (No-Code)

1. Open the **Input** tab in Apify Console
2. Enter one or more **Company Names** (e.g. `construction`, `trucking`, `hvac`) in the search list
3. Select **States** to narrow the search — or leave empty to search all 57 US states and territories
4. Choose a **Date Range** (default: Last 10 years)
5. Optionally select **Filing Types** (e.g. `8-K`, `10-K`) or **Business Types** (e.g. `LLC`, `INC`)
6. Click **Save & Run**
7. When the run completes, go to the **Output** tab and download your data as **JSON, CSV, or Excel**

#### Option B — Advanced (Direct EDGAR URLs)

If you already have EDGAR search URLs, paste them directly into the **Start URLs** field. The Actor will scrape them as-is. If your URL doesn't contain a `locationCode`, it automatically expands across all selected states (or all 57 if none are selected).

**Example Start URL:**

```
https://www.sec.gov/edgar/search/#/dateRange=5y&category=custom&entityName=construction&forms=8-K
```

#### Option C — API / Programmatic

Use the [Apify API](https://docs.apify.com/api/v2) to trigger runs programmatically:

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companyNames": ["construction", "trucking"],
    "states": ["TX", "FL", "CA"],
    "dateRange": "5y",
    "filingTypes": ["8-K"]
  }'
```

#### Option D — Local Development

```bash
## Install dependencies
npm install

## Edit your test input
## storage/key_value_stores/default/INPUT.json

## Run locally
apify run
```

Results appear in `storage/datasets/default/` as individual JSON files.

***

### Input

Configure the Actor from the **Input** tab in Apify Console, or edit `INPUT.json` for local runs. No fields are required — any combination of inputs is valid.

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | URL list | `[]` | Direct EDGAR search URLs. If provided, takes priority over keyword/state URL building. URLs without `locationCode` are auto-expanded per state. |
| `companyNames` | string list | — | Company name, ticker, CIK number, or keyword (e.g. `construction`, `TSLA`, `1234567`) |
| `keywords` | string | — | Full-text keyword filter applied inside filings. Supports exact phrases with double quotes (e.g. `"fiduciary product"`). |
| `states` | multi-select | all 57 | US state/territory codes to search. Leave empty to run across all 57 states and territories. |
| `dateRange` | select | `10y` | Filing date range: `all`, `10y`, `5y`, `1y`, `30d`, or `custom` |
| `dateFrom` | string | — | Custom range start date in `YYYY-MM-DD` format. Only used when `dateRange` is `custom`. |
| `dateTo` | string | — | Custom range end date in `YYYY-MM-DD` format. Only used when `dateRange` is `custom`. |
| `filingTypes` | string list | — | Filter by specific SEC form types (e.g. `8-K`, `10-K`, `S-1`). Do not use together with Filing Category — only one can be active. If both are set, Filing Types takes priority. |
| `filingCategory` | select | `all` | Filter by a broad EDGAR filing category. Do not use together with Filing Types — only one can be active. If both are set, Filing Types takes priority. |
| `maxPagesPerSearch` | integer | `0` | Max result pages per keyword × state search. Each page has ~10 results. `0` = unlimited. |
| `businessTypes` | multi-select | all | Filter output records by entity type (LLC, INC, CORP, LLP, …). Empty = keep all types. |
| `proxyConfiguration` | proxy | Apify Proxy | Proxy settings for avoiding SEC rate limits on large-scale runs. |

#### Example Input (JSON)

```json
{
    "companyNames": ["construction", "trucking", "hvac"],
    "states": ["TX", "FL", "CA", "NY"],
    "businessTypes": ["LLC", "INC"],
    "dateRange": "5y",
    "filingTypes": ["8-K"],
    "maxPagesPerSearch": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

***

### Output

Each scraped record is pushed to the Apify **Dataset**. You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel** from the Storage tab or via the Apify API.

#### Example Output Record (JSON)

```json
{
    "searchUrl": "https://www.sec.gov/edgar/search/#/dateRange=5y&category=custom&locationCode=AL&entityName=construction&forms=8-K",
    "filingDetailUrl": "https://www.sec.gov/Archives/edgar/data/1718227/000162828026021750/0001628280-26-021750-index.htm",
    "searchKeyword": "construction",
    "businessName": "Construction Partners, Inc.",
    "businessType": "INC",
    "secAccessionNo": "SEC Accession No. 0001628280-26-021750",
    "cikNumber": "1718227",
    "cikUrl": "https://www.sec.gov/cgi-bin/browse-edgar?CIK=0001718227&action=getcompany",
    "role": "Filer",
    "filingDate": "2026-03-27",
    "filingType": "8-K",
    "businessAddress": "290 HEALTHWEST DR., SUITE 2, DOTHAN AL 36303",
    "mailingAddress": "290 HEALTHWEST DR., SUITE 2, DOTHAN AL 36303",
    "ownerOrMemberName": "Construction Partners, Inc.  (ROAD)",
    "phoneNumber": "334.673.9763",
    "state": "AL",
    "stateOfIncorporation": "DE",
    "sicCode": "1600 Heavy Construction Other Than Bldg Const - Contractors",
    "ein": "260758017",
    "fiscalYearEnd": "0930",
    "filers": [{ "name": "Construction Partners, Inc.", "role": "Filer", "cikNumber": "1718227", "..." }],
    "formGroupingData": [{ "Item 5.07": "Submission of Matters to a Vote of Security Holders" }],
    "documentLinks": [
        { "text": "road-20260324.htm", "url": "https://www.sec.gov/ix?doc=/Archives/edgar/..." }
    ]
}
```

***

### Data Fields

| Field | Format | Description |
|---|---|---|
| `searchUrl` | link | The EDGAR search URL that produced this result |
| `filingDetailUrl` | link | Direct link to the SEC EDGAR filing index page |
| `searchKeyword` | text | The keyword or company name used to find this record |
| `businessName` | text | Legal company name as registered with the SEC |
| `businessType` | text | Detected entity type extracted from the company name (LLC, INC, CORP, LLP, etc.) |
| `secAccessionNo` | text | SEC Accession Number — unique identifier for this specific filing submission |
| `cikNumber` | text | SEC Central Index Key — the SEC's unique numeric identifier for the company |
| `cikUrl` | link | Link to the company's full filing history on EDGAR |
| `role` | text | The company's role in this filing (Filer, Issuer, Reporting Owner, etc.) |
| `filingDate` | date | Date the filing was submitted and accepted by the SEC |
| `filingType` | text | SEC form type (8-K, 10-K, S-1, 10-Q, DEF 14A, etc.) |
| `businessAddress` | text | Primary business street address as declared in the filing |
| `mailingAddress` | text | Mailing address (may differ from business address) |
| `ownerOrMemberName` | text | Owner, officer, or member name listed on the filing |
| `phoneNumber` | text | Business phone number listed on the filing |
| `state` | text | US state/territory code that was searched (e.g. `AL`, `TX`, `CA`) |
| `stateOfIncorporation` | text | State or country where the company is legally incorporated |
| `sicCode` | text | Standard Industrial Classification code with full description |
| `ein` | text | Employer Identification Number (federal tax ID) |
| `fiscalYearEnd` | text | Fiscal year end in MMDD format (e.g. `0930` = September 30, `1231` = December 31) |
| `filers` | array | All filers listed on the filing — each with their name, role, CIK, addresses, EIN, SIC, and filing info |
| `formGroupingData` | array | Filing sections and items declared in the form (e.g. Item 5.07, Item 7.01) |
| `documentLinks` | array | All document files attached to this filing (HTM, XML, TXT) with text labels and direct URLs |

***

### Pricing / Cost Estimation

This Actor uses a **Puppeteer (full Chrome browser)** crawler because the SEC EDGAR search is a JavaScript-heavy Vue.js single-page application that cannot be scraped with lightweight HTTP tools.

#### What Affects Cost?

| Factor | Impact |
|---|---|
| Number of keywords × states | More combinations = more browser sessions opened |
| `maxPagesPerSearch` value | Higher limit = more result pages and detail pages visited |
| Selected states vs. all 57 | Narrowing to fewer states is the biggest cost lever |
| Business type filter | Filtering to LLC/INC only reduces unnecessary detail page visits |
| Filing type filter | Narrowing to `8-K` or `10-K` produces fewer total results |

#### Estimates

| Scenario | Approx. Compute Units |
|---|---|
| 1 keyword, 1 state, unlimited pages | 0.5 – 2 CU |
| 1 keyword, all 57 states, unlimited pages | 10 – 40 CU |
| 5 keywords, 10 states, max 5 pages each | 2 – 8 CU |
| 7 keywords, all 57 states, unlimited pages | 50 – 200 CU |

#### Tips to Reduce Cost

- **Select only the states you need** — the single biggest lever. Instead of all 57, pick your 5–10 target markets.
- **Set `maxPagesPerSearch`** — e.g. `5` limits to ~500 results per keyword × state. Ideal for recent-filing lead lists.
- **Use `dateRange: "30d"` or `"1y"`** — limits results to recent filings only, cutting total page count dramatically.
- **Use `businessTypes` filter** — if you only want LLCs, set `businessTypes: ["LLC"]` to skip irrelevant detail pages.
- **Filter by `filingTypes`** — focusing on `8-K` or `10-K` significantly reduces results for broad industry keywords.

***

### Tips and Advanced Options

#### Targeting Specific Industries

Use SIC-code-relevant keywords for better precision:

- **HVAC:** `hvac`, `air conditioning`, `heating contractor`
- **Trucking / Freight:** `trucking`, `freight`, `logistics`, `transportation`
- **Construction:** `construction`, `contractor`, `excavation`, `paving`, `roofing`
- **Insurance:** `life insurance`, `auto insurance agent`, `insurance agency`
- **Real Estate:** `real estate`, `property management`, `realty`, `mortgage`
- **Financial Services:** `investment advisor`, `wealth management`, `financial planning`

#### Date Range for Lead Prospecting

Use `"30d"` for the freshest new filings for immediate outreach. Use `"1y"` for a rolling annual pipeline. Use `"custom"` with `dateFrom` and `dateTo` to target a specific quarter or fiscal year.

#### Direct EDGAR URL Mode (startUrls)

Build your own search at [efts.sec.gov](https://efts.sec.gov/LATEST/search-index), copy the resulting URL, and paste it into `startUrls`. The Actor honors your exact parameters. URLs without a `locationCode` are auto-expanded across all selected states, giving you full geographic coverage in one config.

#### Scheduling Runs

In Apify Console, go to **Schedules** to run the Actor automatically — e.g. every Monday morning to get a fresh weekly list of new filings in your target industry.

#### Deploying to Apify Platform

```bash
apify login     # Authenticate with your Apify account
apify push      # Build and deploy the Actor to your Apify account
```

After deploying, run from Apify Console, via the Apify API, or on a recurring schedule.

***

### FAQ, Disclaimers, and Support

#### Is scraping SEC EDGAR legal?

**Yes.** SEC EDGAR is a publicly funded, freely accessible U.S. government database. All data it contains is public record. This Actor reads only publicly available filing data using the same URLs a browser would use, and does not bypass any authentication, access control, CAPTCHA, or terms of service. The SEC explicitly encourages programmatic access to EDGAR data through its public APIs and full-text search system.

#### How many results can EDGAR return per search?

EDGAR caps full-text search results at **10,000 per query**. For very broad keywords across all states, use more specific search terms, add a filing type filter, or narrow the date range to stay under this limit per individual search.

#### Why are some address or phone fields empty?

Not all SEC filers are required to disclose every field. Smaller companies or certain filing types may omit mailing address, phone number, or EIN. The Actor captures all fields that are present in the specific filing index page.

#### Can I get historical filings?

Yes. Set `dateRange: "all"` to retrieve filings going back to the early 2000s. EDGAR's full-text search index covers filings from approximately 2001 onwards.

#### Why does the Actor use a full browser instead of HTTP requests?

The EDGAR Full-Text Search is a Vue.js single-page application. Search results are rendered by JavaScript in response to URL hash changes — they cannot be retrieved by a simple HTTP request. Puppeteer simulates a real browser, triggers the Vue Router navigation, and waits for results to fully render before extracting them.

#### Known Limitations

- EDGAR search is capped at 10,000 results per query
- The Actor runs with `maxConcurrency: 1` to respect SEC server capacity and avoid rate limiting
- EDGAR's full-text index covers filings from ~2001 onwards (pre-2001 filings exist but are not indexed)
- Companies with multiple filers may appear in multiple states if their filings are indexed under different jurisdictions

#### Need Help or Found a Bug?

Open an issue in the **Issues** tab of this repository. Please include your input JSON and the relevant log output from the failed run.

#### Need a Custom Solution?

This Actor can be extended to filter by SIC code, push results directly to Google Sheets, fire a webhook on each new filing, or integrate with Salesforce, HubSpot, or Airtable. Contact us through Apify Console for a custom development quote.

***

### Resources

- [SEC EDGAR Full-Text Search](https://efts.sec.gov/LATEST/search-index) — the underlying search engine this Actor automates
- [SEC EDGAR Company Search](https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany) — browse filings by CIK or company name
- [SEC EDGAR API Documentation](https://efts.sec.gov/LATEST/search-index?q=%22construction%22\&dateRange=custom\&startdt=2020-01-01\&enddt=2024-12-31) — direct API reference
- [Apify Platform Documentation](https://docs.apify.com/platform)
- [Apify SDK for JavaScript](https://docs.apify.com/sdk/js)
- [Crawlee Web Scraping Library](https://crawlee.dev)
- [Join the Apify Developer Community on Discord](https://discord.com/invite/jyEM2PRvMU)

# Actor input Schema

## `startUrls` (type: `array`):

Provide EDGAR full-text search URLs directly (e.g. https://www.sec.gov/edgar/search/#/entityName=construction\&locationCode=AL\&dateRange=5y). If provided, these are used instead of building URLs from Company Names + States. Multiple URLs are all scraped.

## `keywords` (type: `string`):

Search filings for a word or a list of words. A filing must contain all the words to return. Use double quotes for exact phrases, e.g. "fiduciary product". Leave empty to skip keyword filtering.

## `companyNames` (type: `array`):

Search SEC EDGAR by company name, stock ticker, CIK number, or individual's name. Enter one or more search terms.

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

US state/territory codes to search. Leave empty to search ALL states from state.json.

## `dateRange` (type: `string`):

Filing date range filter for the EDGAR search.

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

Start date for custom range in YYYY-MM-DD format (e.g., 2015-01-01). Only used when Date Range is 'Custom'.

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

End date for custom range in YYYY-MM-DD format (e.g., 2025-12-31). Only used when Date Range is 'Custom'.

## `filingTypes` (type: `array`):

Filter by specific SEC EDGAR form types (e.g. 8-K, 10-K, D). Do NOT use together with Filing Category — only one filter can be active at a time. If both are selected, Filing Types takes priority and Filing Category is ignored.

## `filingCategory` (type: `string`):

Filter results by a broad filing category. Do NOT use together with Filing Types — only one filter can be active at a time. If both are selected, Filing Types takes priority and this field is ignored.

## `maxPagesPerSearch` (type: `integer`):

Maximum number of result pages to scrape per company×state search. Each page has ~100 results. Set 0 for unlimited.

## `businessTypes` (type: `array`):

Filter results by business entity type. Leave empty to scrape ALL business types. Select one or more to only keep companies matching those types.

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

Proxy settings for the scraper. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.sec.gov/edgar/search/#/q=drives&dateRange=all&locationCode=CA&entityName=DRIVES"
    }
  ],
  "keywords": "",
  "companyNames": [
    "pizza"
  ],
  "states": [
    "CA"
  ],
  "dateRange": "1y",
  "filingTypes": [],
  "filingCategory": "form-cat0",
  "maxPagesPerSearch": 3,
  "businessTypes": [
    "LLC"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.sec.gov/edgar/search/#/q=drives&dateRange=all&locationCode=CA&entityName=DRIVES"
        }
    ],
    "keywords": "",
    "companyNames": [
        "pizza"
    ],
    "states": [
        "CA"
    ],
    "dateRange": "1y",
    "filingTypes": [],
    "filingCategory": "form-cat0",
    "maxPagesPerSearch": 3,
    "businessTypes": [
        "LLC"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyspider/sec-gov-compony-data-scp").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 = {
    "startUrls": [{ "url": "https://www.sec.gov/edgar/search/#/q=drives&dateRange=all&locationCode=CA&entityName=DRIVES" }],
    "keywords": "",
    "companyNames": ["pizza"],
    "states": ["CA"],
    "dateRange": "1y",
    "filingTypes": [],
    "filingCategory": "form-cat0",
    "maxPagesPerSearch": 3,
    "businessTypes": ["LLC"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapyspider/sec-gov-compony-data-scp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.sec.gov/edgar/search/#/q=drives&dateRange=all&locationCode=CA&entityName=DRIVES"
    }
  ],
  "keywords": "",
  "companyNames": [
    "pizza"
  ],
  "states": [
    "CA"
  ],
  "dateRange": "1y",
  "filingTypes": [],
  "filingCategory": "form-cat0",
  "maxPagesPerSearch": 3,
  "businessTypes": [
    "LLC"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapyspider/sec-gov-compony-data-scp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapyspider/sec-gov-compony-data-scp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/qo1rRHDZTeRxG3poo/builds/XeoMkYbGvKUi7tDXp/openapi.json