# SEC EDGAR Filings & Form D Funding Monitor (`yourevenings/sec-edgar-filings`) Actor

Company filings from SEC EDGAR's official public data: filings by ticker or CIK, the latest filings of any form, Form D private funding rounds with offering amounts, full-text search and XBRL key financials. No API key. Monitor mode returns only new filings.

- **URL**: https://apify.com/yourevenings/sec-edgar-filings.md
- **Developed by:** [Your Evenings](https://apify.com/yourevenings) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 filing returneds

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 EDGAR Filings & Form D Funding Monitor

**SEC EDGAR Filings & Form D Funding Monitor** returns US company filings from the SEC's official public EDGAR data in clean JSON rows, with **no API key needed**. Five modes:

- **Filings by company**: the filings of the tickers or CIKs you list (8-K, 10-K, 10-Q, S-1, proxy statements and so on), newest first.
- **Latest filings**: every filing of the form types you choose, across all companies, from the SEC daily indexes.
- **Form D private offerings**: new private funding rounds with the amount offered and sold, industry group, issuer state, securities type and exemption, parsed from each Form D.
- **Full-text search**: filings whose text matches a word or phrase (the SEC full-text index covers 2001 onwards).
- **Key financials**: the latest annual and quarterly revenue, operating income, net income, diluted EPS, operating cash flow, assets, liabilities, equity, cash, long-term debt and shares outstanding, from the company's XBRL data.

Turn on **monitor mode** and schedule the Actor daily to get only the filings you haven't seen before.

Use it as an **SEC EDGAR** API for **SEC filings**: an **EDGAR company search** by ticker or CIK, an **EDGAR full-text search** you can schedule, and a **Form D** feed of new private funding rounds, with rows you can export as CSV, JSON or Excel.

> **Not an official SEC product.** This Actor is independent and is not affiliated with or endorsed by the U.S. Securities and Exchange Commission. It uses data the SEC publishes for the public on EDGAR. Filings are as submitted by the filers; the SEC does not check them for accuracy.

### Why this one

- **Official SEC sources only, no key.** Rows come from the SEC's own JSON APIs (submissions and XBRL company facts), its daily form indexes, the Form D XML documents and EDGAR full-text search.
- **Form D rows you can filter.** Each offering is read from its Form D document, so you can filter by industry group, issuer state, minimum offering size and securities type, and leave out pooled investment funds (on by default) to keep operating companies.
- **Filters are applied before you're charged.** You pay only for rows that match. Status rows (not found, no matches, budget reached and so on) are free.
- **Company data only.** Forms 3, 4, 5 and 144 and Schedules 13D and 13G (mostly filed by individuals about their own holdings) are never returned. In Form D rows, the names and addresses of related persons, signers and sales-compensation recipients are dropped; you get how many were listed. Issuer phone numbers and street addresses are dropped too. CIKs that belong to individuals are skipped with a free status row.
- **Polite to the SEC.** Every request declares who is making it, as the SEC asks, and requests are paced to at most 5 per second, half the SEC's fair-access limit of 10.
- **Dates roll forward.** `filedWithinDays` counts back from each run, so a saved, scheduled task always covers the latest days.

### Quick start

Press **Start** with the prefilled input, or paste this into the **JSON** view of the Input tab. It returns up to 10 of the latest 8-K, 10-K and 10-Q filings of Apple, Microsoft and NVIDIA filed in the last 90 days.

```json
{
  "mode": "companyFilings",
  "companies": ["AAPL", "MSFT", "NVDA"],
  "formTypes": ["8-K", "10-K", "10-Q"],
  "filedWithinDays": 90,
  "maxResults": 10
}
```

In our test run on 26 October 2026 it returned 10 filings (8-Ks, 10-Qs and a 10-K filed from 29 July to 3 September), which costs about $0.02 (see Pricing). The prefilled window is 90 days because these companies file a 10-Q or 10-K once a quarter; with a 30-day window (the API default) the same run on 26 October returned no filings.

New private funding rounds of at least $1 million from operating companies (pooled funds left out), from the last published SEC daily index:

```json
{
  "mode": "formD",
  "filedWithinDays": 3,
  "minOfferingUsd": 1000000,
  "maxResults": 50
}
```

### Where the data comes from

| Mode | SEC source | How fresh |
|---|---|---|
| Filings by company | `data.sec.gov/submissions` (the company's recent filings, plus older pages when your date window needs them) | Updated by the SEC as filings are accepted |
| Latest filings, Form D | EDGAR daily form indexes (`Archives/edgar/daily-index`) and, for Form D, each filing's `primary_doc.xml` | Each business day's index is published in the evening (US Eastern time); there are none at weekends or on federal holidays. The SUMMARY record shows the latest index date read |
| Full-text search | EDGAR full-text search (`efts.sec.gov`) | As indexed by the SEC |
| Key financials | `data.sec.gov/api/xbrl/companyfacts` | Updated by the SEC as XBRL filings are accepted |

### Who it's for

- **Investors, analysts and researchers** who follow US public companies' filings and figures.
- **VC, private-equity and B2B sales teams** looking for companies that have just raised private money.
- **Data and product teams** feeding filing data into spreadsheets, CRMs or AI agents.

### Use cases

1. **Event alerts for a watchlist.** New 8-Ks, with item numbers such as 2.02 (results), 5.02 (officer changes) and 1.01 (material agreements), for the companies you follow. Turn on `monitorMode` and schedule it daily.
2. **Deal sourcing from Form D.** A daily list of companies that just raised private money, filtered by industry group, state and minimum offering size.
3. **Phrase research and financial screening.** Find every filing that mentions a phrase, such as "going concern" or "material weakness", in a date window, or get the latest annual and quarterly figures for a list of companies in one layout.

### Output sample

Five of the 10 rows from the Quick start input (run on 26 October 2026):

| Company | Ticker | Form | Filed | Report date | 8-K items |
|---|---|---|---|---|---|
| NVIDIA CORP | NVDA | 8-K | 2026-09-03 | 2026-09-02 | 8.01 |
| MICROSOFT CORP | MSFT | 8-K | 2026-09-02 | 2026-09-02 | 7.01, 9.01 |
| NVIDIA CORP | NVDA | 10-Q | 2026-08-26 | 2026-07-26 | – |
| NVIDIA CORP | NVDA | 8-K | 2026-08-26 | 2026-08-26 | 2.02, 9.01 |
| MICROSOFT CORP | MSFT | 10-K | 2026-07-29 | 2026-06-30 | – |

One 8-K row and one Form D row as JSON, from two runs on 30 October 2026 (build 0.1.5). Some fields are left out to keep it short; the full list is under Output.

```json
{
  "rowType": "filing",
  "cik": "0001326801",
  "companyName": "Meta Platforms, Inc.",
  "tickers": [
    "META"
  ],
  "exchanges": [
    "Nasdaq"
  ],
  "sic": "7370",
  "sicDescription": "Services-Computer Programming, Data Processing, Etc.",
  "stateOfIncorporation": "DE",
  "businessState": "CA",
  "filerCategory": "Large accelerated filer",
  "form": "8-K",
  "filingDate": "2026-10-29",
  "reportDate": "2026-10-26",
  "accessionNumber": "0001193125-26-438017",
  "items": [
    "1.01",
    "3.03",
    "5.03",
    "9.01"
  ],
  "primaryDocDescription": "8-K",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1326801/000119312526438017/0001193125-26-438017-index.htm",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/1326801/000119312526438017/d183592d8k.htm"
}
```

```json
{
  "rowType": "form_d_offering",
  "cik": "0002160814",
  "companyName": "Bluesonde Technologies, Inc.",
  "form": "D",
  "isAmendment": false,
  "filingDate": "2026-10-29",
  "accessionNumber": "0002160814-26-000001",
  "entityType": "Corporation",
  "jurisdictionOfIncorporation": "DELAWARE",
  "yearOfIncorporation": 2025,
  "issuerCity": "PORTLAND",
  "issuerState": "ME",
  "industryGroup": "Other Technology",
  "revenueRange": "Decline to Disclose",
  "federalExemptions": [
    "06b"
  ],
  "dateOfFirstSale": "2025-11-11",
  "securitiesOffered": [
    "option_warrant_right"
  ],
  "minimumInvestmentUsd": 0,
  "totalOfferingAmountUsd": 1000000,
  "totalAmountSoldUsd": 1000000,
  "totalRemainingUsd": 0,
  "totalNumberAlreadyInvested": 10,
  "relatedPersonsCount": 3,
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/2160814/000216081426000001/0002160814-26-000001-index.htm"
}
```

### Input examples

Paste any of these into the **JSON** view of the Input tab. Each one is the input of a ready-made example task.

#### 8-K filings from six big tech companies

```json
{
  "mode": "companyFilings",
  "companies": ["AAPL", "MSFT", "NVDA", "GOOGL", "AMZN", "META"],
  "formTypes": ["8-K"],
  "includeAmendments": true,
  "filedWithinDays": 30,
  "maxResults": 50
}
```

#### Form D tech funding rounds of $1M or more

```json
{
  "mode": "formD",
  "industryGroups": ["Other Technology", "Computers"],
  "minOfferingUsd": 1000000,
  "excludePooledFunds": true,
  "filedWithinDays": 7,
  "maxResults": 100
}
```

#### EDGAR full-text search: "going concern" in 10-Ks and 10-Qs

```json
{
  "mode": "fullTextSearch",
  "fullTextQuery": "\"going concern\"",
  "formTypes": ["10-K", "10-Q"],
  "filedWithinDays": 30,
  "maxResults": 50
}
```

### Input

| Field | Used by | What it does |
|---|---|---|
| `mode` | all | `companyFilings` (default), `latestFilings`, `formD`, `fullTextSearch` or `financials`. |
| `companies` | companyFilings, financials | Tickers (`AAPL`, `BRK-B` or `BRK.B`) or CIK numbers (`320193`). Up to 200. |
| `formTypes` | companyFilings, latestFilings, fullTextSearch | Forms to return, e.g. `8-K`, `10-K`, `S-1`, `DEF 14A`. Empty means all forms (excluded forms are never returned). |
| `includeAmendments` | all filing modes | Also return `/A` amendments. Default `true`. |
| `filedWithinDays` | all except financials | Date window counted back from today. Default 30. |
| `filedSince`, `filedUntil` | all except financials | Fixed dates (YYYY-MM-DD). `filedSince` overrides `filedWithinDays`. |
| `companyNameKeywords` | latestFilings, formD | Keep companies whose name contains any of these whole words. |
| `industryGroups` | formD | Form D industry groups, e.g. `Biotechnology`, `Other Technology`. Partial, case-insensitive. |
| `issuerStates` | formD | Two-letter state codes, e.g. `CA`. |
| `minOfferingUsd` | formD | Minimum of the larger of total offering amount and amount sold. |
| `securityTypes` | formD | `equity`, `debt`, `option_warrant_right`, `security_to_be_acquired`, `pooled_investment_fund`, `tenant_in_common`, `mineral_property`, `other`. |
| `excludePooledFunds` | formD | Leave out pooled investment funds. Default `true`. |
| `fullTextQuery` | fullTextSearch | Words or a "quoted phrase". |
| `maxResults` | all | Most rows per run, newest first. Default 10; 0 means no limit. |
| `monitorMode`, `emitBaselineOnFirstRun`, `stateStoreName` | all | See *Monitor mode* below. |
| `requestTimeoutSecs` | all | Per-request timeout, 5 to 120 seconds. |

Limits per run: 200 companies, 3,000 Form D documents read, and 20 pages (2,000 document hits) of full-text search. When a limit is reached the run says so in a free status row.

### Output

Every row has `rowType`. Examples (values shortened):

**Filing** (`filing`):

```json
{
  "rowType": "filing",
  "cik": "0001045810",
  "companyName": "NVIDIA CORP",
  "tickers": ["NVDA"],
  "sic": "3674",
  "sicDescription": "Semiconductors & Related Devices",
  "businessCity": "SANTA CLARA",
  "businessState": "CA",
  "form": "8-K",
  "filingDate": "2026-09-03",
  "reportDate": "2026-09-02",
  "accessionNumber": "0001045810-26-000078",
  "items": ["8.01"],
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/1045810/000104581026000078/nvda-20260902.htm",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1045810/000104581026000078/0001045810-26-000078-index.htm"
}
```

Latest filings rows carry the fields in the daily index (company, CIK, form, date, accession number, links). Full-text search rows add the matching documents and the business locations, SIC codes and incorporation states the SEC indexes.

**Form D offering** (`form_d_offering`):

```json
{
  "rowType": "form_d_offering",
  "cik": "0002161925",
  "companyName": "Advanced Glass Holdings, Inc.",
  "form": "D",
  "filingDate": "2026-10-23",
  "entityType": "Corporation",
  "jurisdictionOfIncorporation": "DELAWARE",
  "yearOfIncorporation": 2023,
  "issuerCity": "WILMETTE",
  "issuerState": "IL",
  "industryGroup": "Other",
  "federalExemptions": ["06b"],
  "dateOfFirstSale": "2026-10-09",
  "securitiesOffered": ["equity"],
  "minimumInvestmentUsd": 0,
  "totalOfferingAmountUsd": 2000000,
  "totalAmountSoldUsd": 2000000,
  "totalRemainingUsd": 0,
  "totalNumberAlreadyInvested": 10,
  "relatedPersonsCount": 5,
  "formDocumentUrl": "https://www.sec.gov/Archives/edgar/data/2161925/000216192526000001/primary_doc.xml"
}
```

**Key financials** (`company_financials`): `latestAnnual` and `latestQuarter`, each with the period end, fiscal year, form, filing date, accession number and a `values` object. Every value names the XBRL concept it came from, its period and the filing it was reported in. A figure the company didn't report for that period is `null` and listed in `notReportedForThisPeriod`, rather than filled with an older number.

**Status** (`status`, free): `not_found`, `skipped_individual_filer`, `no_matches`, `no_data`, `no_xbrl_data`, `scan_limit`, `partial`, `source_error` or `budget_reached`, each with a plain-English `message`.

The **SUMMARY** record in the default key-value store lists the filters used, rows by type, the daily indexes read (and the latest one), candidates and matches, Form D documents read, request counts and the run time. The dataset has views for Overview, Filings, Form D offerings, Key financials and Status rows.

### Monitor mode: only new filings

Set `monitorMode` to `true` and schedule a saved task (daily suits the SEC's daily indexes). The Actor remembers the accession numbers it has returned (for 400 days) in the named key-value store `stateStoreName`, and returns only filings it hasn't returned before, marked `changeType: "new"`. For Key financials, a company row is new when a newer annual or quarterly report has been filed. Known Form D filings are skipped before their documents are downloaded.

- `emitBaselineOnFirstRun` (default `true`) returns current matches on the first run. Set it to `false` to remember them silently, without charge, and get only later filings.
- Use a different `stateStoreName` for each separate monitor.
- If a source fails during a run, rows already returned are remembered and nothing is forgotten, so the next run doesn't charge for them again.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Filing returned | $0.002 |
| Form D offering returned | $0.003 |
| Company financials returned | $0.003 |
| Alert run with new matches (monitor mode only, once per run that returns at least one new row) | $0.01 |
| Actor start | $0.00005 |

Higher Apify plans get lower prices (shown on the Pricing tab). Status rows, the SUMMARY record and monitor runs with nothing new are free of row and alert charges. Set **Maximum cost per run** in the run options: the Actor stops before going over it and adds a free `budget_reached` row, and in monitor mode filings not returned are returned on a later run.

### Use it from code, spreadsheets or an AI agent

Run it with the Apify API or client libraries, schedule it, or connect it to Make, Zapier, Google Sheets or webhooks through Apify integrations. AI agents can call it through Apify's MCP server.

### FAQ

**Is this the SEC's official API?** No. It reads the SEC's official public data and APIs, and is not affiliated with the SEC.

**Why are Form 4 insider trades not included?** They are filed about individuals' own holdings and trades. This Actor returns company data only, so Forms 3, 4, 5, 144 and Schedules 13D/13G are left out.

**Why are today's filings missing from Latest filings and Form D?** Those modes read the SEC daily indexes, which are published each business-day evening. Use **Filings by company** for a company's filings as soon as the SEC has them.

**Are Form D amounts the amount raised?** Form D reports the total offering amount and the amount sold so far at the time of filing; amendments update them. A Form D is a notice of an exempt offering, not a registration, and the SEC does not review it.

**Can I get older filings?** Yes. Set `filedSince`. Filings by company pages back through the company's older filings as needed; Latest filings and Form D read one daily index per business day in your window.

**How do I search SEC filings by company?**
Use **Filings by company** (`mode: "companyFilings"`) with tickers or CIKs in `companies`, and pick form types such as 8-K, 10-K or 10-Q. Rows are newest first, with links to the filing index and the main document on EDGAR.

**How do I run an EDGAR full-text search?**
Use `mode: "fullTextSearch"` and put the word or phrase in `fullTextQuery` (quotes for an exact phrase), optionally with `formTypes`. It uses the SEC's own full-text index, which covers 2001 onwards.

**How do I find new Form D filings?**
Use `mode: "formD"` with `filedWithinDays`, and filter by `industryGroups`, issuer state or `minOfferingUsd`. Each row has the amount offered and sold, parsed from the Form D document.

### Feedback

Found a problem or need a field? Open an issue on the Issues tab.

Requests to SEC.gov identify this Actor by company name and contact address, as the SEC asks of automated tools.

# Changelog

This Actor's version history is a separate document: https://apify.com/yourevenings/sec-edgar-filings/changelog.md

# Actor input Schema

## `mode` (type: `string`):

<b>Filings by company</b>: filings of the companies you list. <b>Latest filings</b>: every filing of the chosen form types from the SEC daily indexes. <b>Form D</b>: new private offerings with amount raised, industry and state. <b>Full-text search</b>: filings whose text matches your query. <b>Key financials</b>: latest annual and quarterly revenue, income, cash flow and balance sheet figures.

## `companies` (type: `array`):

For <b>Filings by company</b> and <b>Key financials</b>. Tickers as listed by the SEC (<code>AAPL</code>, <code>BRK-B</code> or <code>BRK.B</code>) or CIK numbers (<code>320193</code>). Up to 200 per run.

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

Only return these forms, for example <code>8-K</code>, <code>10-K</code>, <code>10-Q</code>, <code>S-1</code>, <code>424B4</code>, <code>DEF 14A</code>, <code>6-K</code>, <code>20-F</code>. Leave empty for all forms. Not used by Form D mode (always Form D) or Key financials.

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

Also return amendments of the chosen forms, for example 8-K/A for 8-K and D/A for Form D.

## `filedWithinDays` (type: `integer`):

Date window when 'Filed since' is empty. The SEC publishes each day's index in the evening (US Eastern time) and none at weekends or on federal holidays, so Latest filings and Form D runs cover up to the last published day.

## `filedSince` (type: `string`):

Optional start date. Overrides 'Filed within the last N days'.

## `filedUntil` (type: `string`):

Optional end date. Defaults to today.

## `companyNameKeywords` (type: `array`):

Latest filings and Form D: keep only companies whose name contains any of these whole words, for example <code>therapeutics</code> or <code>bio</code>.

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

Keep offerings in any of these Form D industry groups, for example <code>Biotechnology</code>, <code>Other Technology</code>, <code>Computers</code>, <code>Commercial</code>, <code>Other Health Care</code>, <code>Residential</code>, <code>Oil and Gas</code>. Case-insensitive; partial words match (<code>health</code>).

## `issuerStates` (type: `array`):

Two-letter codes of the issuer's principal place of business, for example <code>CA</code>, <code>NY</code>, <code>TX</code>.

## `minOfferingUsd` (type: `integer`):

Keep offerings whose total offering amount, or amount sold so far, is at least this. Offerings marked 'Indefinite' are kept only when this is 0.

## `securityTypes` (type: `array`):

Keep offerings of any of these: <code>equity</code>, <code>debt</code>, <code>option_warrant_right</code>, <code>security_to_be_acquired</code>, <code>pooled_investment_fund</code>, <code>tenant_in_common</code>, <code>mineral_property</code>, <code>other</code>.

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

Skip hedge, private equity, venture capital and other pooled funds, leaving operating companies. Turn off to include fund raises.

## `fullTextQuery` (type: `string`):

Words or a "quoted phrase" to find in filing documents, for example <code>"going concern"</code> or <code>"cybersecurity incident"</code>. Combine with Form types and the date window. One row per filing, with up to 10 matching documents.

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

Most rows to return in this run (newest first across all companies). 0 means no limit. In monitor mode it counts new rows only. Free status rows don't count.

## `monitorMode` (type: `boolean`):

Remember what was returned and only return filings not seen in earlier runs. Schedule the Actor daily. A $0.01 alert event is charged once on runs that return at least one new row; runs with nothing new don't pay it. For Key financials, a row is new when a newer annual or quarterly report is filed.

## `emitBaselineOnFirstRun` (type: `boolean`):

On: the first monitor run returns current matches (up to Maximum rows). Off: it only remembers them silently (no charge) and later runs return what's new.

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

Named key-value store that keeps what monitor mode has already returned. Use a different name for each separate monitor (saved task).

## `requestTimeoutSecs` (type: `integer`):

Timeout for each request to SEC servers. Requests are paced to at most 5 per second, below the SEC's 10 per second fair-access limit; this can't be raised.

## Actor input object example

```json
{
  "mode": "companyFilings",
  "companies": [
    "AAPL",
    "MSFT",
    "NVDA"
  ],
  "formTypes": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "includeAmendments": true,
  "filedWithinDays": 90,
  "minOfferingUsd": 0,
  "excludePooledFunds": true,
  "maxResults": 10,
  "monitorMode": false,
  "emitBaselineOnFirstRun": true,
  "stateStoreName": "sec-edgar-filings-state",
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

Overview view of the dataset.

## `filings` (type: `string`):

Filings view of the dataset.

## `formD` (type: `string`):

Form D offerings view of the dataset.

## `financials` (type: `string`):

Key financials view of the dataset.

## `status` (type: `string`):

Status rows (free) view of the dataset.

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

SUMMARY record: filters used, rows by type, daily indexes read, request counts, User-Agent and timings.

# 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 = {
    "companies": [
        "AAPL",
        "MSFT",
        "NVDA"
    ],
    "formTypes": [
        "8-K",
        "10-K",
        "10-Q"
    ],
    "filedWithinDays": 90
};

// Run the Actor and wait for it to finish
const run = await client.actor("yourevenings/sec-edgar-filings").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 = {
    "companies": [
        "AAPL",
        "MSFT",
        "NVDA",
    ],
    "formTypes": [
        "8-K",
        "10-K",
        "10-Q",
    ],
    "filedWithinDays": 90,
}

# Run the Actor and wait for it to finish
run = client.actor("yourevenings/sec-edgar-filings").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 '{
  "companies": [
    "AAPL",
    "MSFT",
    "NVDA"
  ],
  "formTypes": [
    "8-K",
    "10-K",
    "10-Q"
  ],
  "filedWithinDays": 90
}' |
apify call yourevenings/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yourevenings/sec-edgar-filings"
        }
    }
}
```

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/snqzoSdzpEiVvTn1o/builds/3c3TjpgJfBb9ddmGf/openapi.json