# SEC Filing Alerts: EDGAR Monitor by Ticker or CIK (`lone_rachis/sec-edgar-filing-monitor`) Actor

SEC filing alerts for a watchlist of tickers or CIKs: new 8-K, 10-K, 10-Q, Form D or any other EDGAR form, one clean row per filing with 8-K item codes explained. On a schedule, each run returns only filings it has not delivered before.

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

## Pricing

from $16.00 / 1,000 filings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does SEC EDGAR Filing Monitor do?

**SEC EDGAR Filing Monitor** watches SEC EDGAR for new filings by the companies you list. Give it tickers or CIKs and the form types you care about: 8-K, 10-K, 10-Q, Form D or any other EDGAR form. It returns one row per filing with the company, the form, the dates and links to the filing on sec.gov. Each 8-K row lists its item codes with their official titles, so you can see at a glance that a filing reports results (2.02) or a change of officers (5.02). Each Form D row carries the offering: total amount, amount sold, industry group, exemptions and date of first sale.

Run it on a schedule. The first run returns every matching filing from the last 30 days. Every later run returns only the filings it has not delivered before, because the Actor remembers what it sent in a key-value store tied to your list. A run that finds nothing new writes one free row that says so. You pay per delivered filing. A ticker that does not exist, a filing whose details cannot be read and a company that could not be checked cost nothing.

The Actor reads SEC's public JSON and XML files only, never HTML pages. It names itself and a contact address in every request, as SEC asks, and sends at most 5 requests a second. It collects nothing about individuals: forms 3, 4, 5 and 144 are refused, and the people listed in a Form D are left out of every row.

### Why use SEC EDGAR Filing Monitor?

EDGAR shows every filing, but watching a list of companies by hand means opening each company page every day and reading each 8-K to learn what it reports. SEC's submissions files hold the facts as parallel arrays and bare codes. This Actor turns them into rows you can filter, and it remembers what you have already seen.

What you get:

- **Only new filings.** The first run reads back as far as you ask (30 days by default, up to 365). After that each run delivers what is new since the run before, and a filing is never delivered or charged twice for the same list.
- **8-K items with their meaning.** `itemCodes` for filtering, `items` with titles, and `itemsText` as one line for a spreadsheet or an alert.
- **Form D offering details.** Amounts offered, sold and remaining, industry group, fund type, revenue or net asset value range, exemptions, security types, first sale date and investor count, read from the filing's XML.
- **Clear statuses.** `ok`, `unparsed`, `not-found`, `failed`, `skipped` or `no-new-filings`, each with a reason in a sentence. Only `ok` rows are charged.
- **Fair use of SEC.** A declared User-Agent, at most 5 requests a second, a wait on HTTP 429 and a full stop after two HTTP 403 answers in a row.

Each claim above has a test behind it:

| What you get | How it works | The test that backs it |
| --- | --- | --- |
| **Only new filings, never charged twice** | Delivered accession numbers are kept in a named key-value store. A later run on the same list skips them. A run that restarts reads its own rows first, so a filing written just before a crash is not sent again. | "a second run on the same list writes no duplicate, charges nothing, and leaves one free no-new-filings row", "B2 a crash after a row is written but before the memory is saved delivers and charges nothing twice", "P1 on migrating the run saves its memory, state and summary, and the restarted run repeats nothing", and the live test "live: the prefill run delivers well-formed rows from SEC, and a second run on the same memory repeats nothing" (12 Oct 2026). |
| **8-K items with titles** | The item codes of each 8-K are matched to the titles in Form 8-K's instructions, items 1.01 to 9.01. | "the prefill input delivers each new 8-K and 10-Q once, charged once, with the declared User-Agent, under 5 requests a second", and the tests in `items.test.mjs`. |
| **Form D details, with no people in them** | The filing's `primary_doc.xml` is read. The related persons, sales agents and signature are cut out of the file before it is parsed, and the issuer's street and phone are never copied. | "Form D filings by CIK come with the offering details, and nothing about any person". A live run on 25 Form D issuers taken from SEC's daily index of 9 Oct 2026 parsed all 25. |
| **No charge for what it could not deliver in full** | A filing whose Form D file is broken comes back as `unparsed` and costs nothing. Unknown tickers and CIKs get a free `not-found` row, and the run goes on. | "a Form D with a broken XML file is delivered without details, free, and not again", "a Form D whose XML is passingly unavailable is delivered free now, and in full on the next run", "an unknown ticker and an unknown CIK each get a free not-found row, and the run goes on". |
| **A spending cap that stops the run** | Set a maximum cost per run. The run stops before it charges past it, and the filings it held back come in the next run. | "P6 the maximum cost per run stops delivery cleanly, and the next run delivers what was held back". |
| **Fair use of SEC** | Requests start at least 210 ms apart. A 429 is waited out. A 403 gets one retry after 10 seconds, then the run sends nothing more and lists the companies it did not reach. | "N3 two 403 answers stop every request to SEC; the companies not reached are listed as skipped, free", "N4 a 429 is waited out and the filing is still delivered", and the gap check in the prefill test. |

Plus what the Apify platform adds around it:

- **API access.** Start runs and read results with the Apify API or the JavaScript and Python clients.
- **Scheduling.** Run it daily, or several times a day, and get only new filings each time.
- **Integrations.** Send new rows to Make, Zapier, Google Sheets, Slack or any webhook.
- **Monitoring.** Run history, logs and alerts for failed runs.

Typical uses are a daily 8-K digest for a portfolio, a feed of new Form D raises by a list of funds or startups, filing alerts for a newsroom, and fresh triggers for a sales team that follows a set of accounts.

### What data can SEC EDGAR Filing Monitor extract?

Each new filing becomes one row in the dataset. The most useful fields:

| Field | Type | What it holds |
| --- | --- | --- |
| `status` | string | `ok`, `unparsed`, `not-found`, `failed`, `skipped` or `no-new-filings`. |
| `companyName` | string | The company name as SEC records it. |
| `cik`, `ticker` | string | SEC's 10-digit company number, and the ticker you gave or the company's first ticker. |
| `form` | string | The form type, such as `8-K`, `10-Q`, `D` or `8-K/A`. |
| `accessionNumber` | string | EDGAR's unique number for the filing. |
| `filingDate`, `reportDate` | string | The filing date and the period or event date it reports on, as YYYY-MM-DD. |
| `acceptanceDateTime` | string | When EDGAR accepted the filing. |
| `filingIndexUrl`, `primaryDocumentUrl` | string | Links to the filing's index page and its main document on sec.gov. |
| `itemCodes`, `items`, `itemsText` | array, array, string | For 8-K and 8-K/A: the item codes, the codes with titles, and the same as one line. Empty for other forms. |
| `formD` | object | For Form D and D/A: the offering details listed below. Empty for other forms. |
| `sic`, `sicDescription`, `stateOfIncorporation`, `exchange` | string | Company facts from SEC's records. |
| `error`, `errorCode` | string | Why a row is not `ok`, as a sentence and as a short code. |
| `stateStore` | string | The name of the key-value store that remembers what this list has received. |

The `formD` object holds company-level facts only:

| Field | What it holds |
| --- | --- |
| `issuerName`, `issuerEntityType`, `issuerJurisdiction`, `issuerYearOfIncorporation` | Who is raising money, its legal form and where it was formed. |
| `issuerCity`, `issuerStateOrCountry` | The city and state of the issuer's address. The street and phone are left out. |
| `industryGroup`, `investmentFundType`, `isInvestmentCompanyAct1940` | Form D item 4. |
| `revenueRange`, `netAssetValueRange` | Form D item 5, as the filer chose it, such as "Decline to Disclose". |
| `federalExemptions` | Codes with titles, such as `06b` Rule 506(b) and `3C.7` Investment Company Act Section 3(c)(7). |
| `isAmendment`, `previousAccessionNumber` | Whether the filing amends an earlier one, and which. |
| `dateOfFirstSale`, `firstSaleYetToOccur`, `offeringLastsMoreThanOneYear` | Timing of the offering. |
| `securityTypes`, `otherSecurityDescription`, `isBusinessCombination` | What is offered. |
| `minimumInvestment`, `totalOfferingAmount`, `totalAmountSold`, `totalRemaining` | Amounts in US dollars. An amount the filer marked as indefinite is empty and `totalOfferingAmountIndefinite` or `totalRemainingIndefinite` is true. |
| `totalInvestors`, `hasNonAccreditedInvestors`, `nonAccreditedInvestors` | Investor counts. |
| `salesCommissions`, `findersFees` | Fees in US dollars. |

Every row that is not `ok` carries one of these codes in `errorCode`, so you can count rows by reason without reading the sentence. The sentence in `error` can be reworded in a later version. The code stays.

| `errorCode` | Meaning |
| --- | --- |
| `ticker-not-found` | SEC's ticker list has no such ticker. |
| `cik-not-found` | SEC has no filing history for that CIK. |
| `ticker-list-unavailable` | SEC's ticker list could not be read, so a ticker could not be turned into a CIK. Give the CIK instead. |
| `duplicate` | The same company appears earlier in your list. It is checked once. |
| `individual-filer` | The CIK belongs to a person who files as an insider. The Actor reads nothing more from it. |
| `parse-failed` | The Form D file could not be read. The filing is delivered without details and is not sent again. |
| `details-missing` | SEC has no Form D file for the filing. The filing is delivered without details. |
| `details-unavailable` | The Form D file could not be fetched this time. The filing is delivered without details and comes again, in full, in the next run. |
| `charge-limit` | The run reached your maximum cost per run. |
| `run-time-limit` | The run reached its time limit. |
| `repeated-failures` | Five companies in a row failed with a server or network error, so the run stopped. |
| `aborted` | The run was stopped. |
| `sec-blocked` | SEC refused two requests in a row (HTTP 403), so the run sent nothing more. |
| `not-found` | A file SEC lists could not be found, such as an older page of a filing history. |
| `rate-limited` | SEC kept answering "too many requests" (HTTP 429) after three waits. |
| `server-error`, `http-error` | SEC answered with an error status. |
| `network-error`, `timeout` | SEC could not be reached, or did not answer within 30 seconds. |
| `too-large`, `bad-response`, `unexpected-redirect` | SEC sent a file over 50 MB, something that was not JSON, or a redirect to another site. |
| `no-new-filings` | The one row a run writes when nothing it checked was new. |
| `other` | Any other reason. The sentence in `error` says what happened. |

### How to monitor SEC EDGAR filings for a list of companies

1. Open the Actor in Apify Console and select the **Input** tab.
2. Add the companies under **Companies**, one per line: tickers such as AAPL, or CIKs such as 320193. The form is prefilled with three large companies, so you can press **Start** to see a result straight away.
3. Choose the **Form types**. The form is prefilled with 8-K and 10-Q. Left empty through the API, the list is 8-K, 10-K, 10-Q and D.
4. Press **Start**. In our local tests the prefilled run took about 10 seconds, and a list of 25 companies took 12 to 22 seconds.
5. Open the **Output** tab for the table, or the **Form D offerings** view for the amounts. Export it as JSON, CSV or Excel.
6. To get only new filings from then on, create a schedule with the same input, for example every morning.

To run it from code, send the same input to the Actor through the API:

```json
{
    "companies": ["AAPL", "MSFT", "1785128"],
    "formTypes": ["8-K", "D"],
    "lookbackDays": 30
}
```

### How to send new SEC filings to Slack or Google Sheets (Make, Zapier, no code)

Each scheduled run holds only the filings that are new since the last run, so you can pass every run's results straight on.

**Slack, built in.** On the Actor's **Integrations** tab, add **Slack**, connect your workspace, pick a channel and choose the event "Run succeeded". Each finished run posts a message with a link to its results.

**Google Sheets with Make.com.**

1. In Make, create a scenario and add the Apify module that watches for finished Actor runs, set to this Actor.
2. Add the Apify module that gets dataset items, and map the run's default dataset ID.
3. Add Google Sheets "Add a Row" and map the fields you want, for example `companyName`, `ticker`, `form`, `filingDate`, `itemsText` and `filingIndexUrl`.
4. Optional: add a filter so only some filings reach the sheet, for example 8-K filings whose `itemCodes` include 2.02 (results) or 5.02 (officer changes).

**Google Sheets or Slack with Zapier.** Use the Apify trigger for a finished Actor run, then the Apify step that fetches dataset items, then a Google Sheets "Create Spreadsheet Row" or a Slack "Send Channel Message" action. A Zapier filter step works the same way as the Make filter.

**Your own code.** Add a webhook on the **Integrations** tab for the event "Run succeeded", and read the dataset from the URL in the payload.

Set a schedule first (see the steps above), so that each run, and each message or row, covers only what is new.

### How much does it cost to monitor SEC filings?

You pay per new filing delivered, and the Apify platform usage for the run is included. A filing costs $0.02 on the Free and Bronze plans, so 1,000 filings cost $20.

| Event | When it is charged | Price |
| --- | --- | --- |
| `filing` | One new filing delivered with status `ok` | $0.02 (Free, Bronze), $0.018 (Silver), $0.016 (Gold) |
| Actor start | Once per run, scaled by memory (Apify standard event) | $0.00005 per GB of memory |

Rows with the status `unparsed`, `not-found`, `failed`, `skipped` or `no-new-filings` cost nothing, and a filing delivered by an earlier run for the same list is never charged again. You can cap a run with the **Maximum cost per run** setting, and the Actor stops cleanly at that limit.

#### How much does one filing cost?

One filing costs $0.02 on the Free and Bronze plans, $0.018 on Silver and $0.016 on Gold. A run adds a start fee of about $0.0000125 at the default memory of 256 MB. The price already includes the platform usage, so there is no second bill for compute. A watchlist that brings 100 new filings in a month costs about $2 for that month.

#### How do I keep a run within budget?

Set **Maximum cost per run** when you start it or in the schedule. The run stops before it would charge past that amount. The filings it did not deliver get one `skipped` row per company with the code `charge-limit`, they stay out of the memory, and the next run delivers them. A first run with a long lookback can bring many filings at once, so start with the default 30 days.

#### What does a scheduled run cost when nothing is new?

Only the start fee, about $0.0000125 at 256 MB. The run writes one `no-new-filings` row and charges nothing for it, so a daily schedule on a quiet list costs almost nothing.

### Input

Open the **Input** tab to see every setting with a short description. The first field is `companies`, the only one you must fill in. The form has two groups after it:

- **Filings:** `formTypes`, `includeAmendments` (on by default, so 8-K/A comes with 8-K) and `lookbackDays` (30 by default, 1 to 365).
- **Memory and contact:** `stateStoreName` and `contactEmail`.

`companies` takes up to 1,000 entries, typed one by one or pasted with **Bulk edit**, one per line. A ticker is written as SEC lists it, so BRK.B and BRK-B are the same. A CIK can be written as 320193, 0000320193 or CIK0000320193. Funds and private companies have no ticker, so give their CIK, which you find on the company's EDGAR page. A company given twice is checked once.

The memory of what was delivered is named after your companies and form types. The same list gives the same memory in any order, so a schedule just works. A changed list starts a new memory, which means the next run delivers the whole lookback window again for the new list. To keep one memory while you add or remove companies, set `stateStoreName` to a new name of your own, such as `my-watchlist`, and let the Actor create the store. A ticker and the CIK of the same company count as two different entries for the name, so keep the list in one spelling.

`contactEmail` is optional. SEC asks every automated tool to name a contact in its requests. Leave it empty to use the Actor developer's address, or give your own if you want SEC to reach you about your runs. It goes to SEC in a request header only and is not stored in the output.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A run also writes a `SUMMARY` record to its key-value store with the counts of delivered, unparsed, not found, failed and skipped entries, the charged filings, the requests sent to SEC and one line per company. Companies with nothing new get no row of their own: they are counted in `SUMMARY`. Every company that could not be checked gets a row with the reason, also when the run stops early at the cost cap, after SEC refused twice or near the time limit of the run. A run in which no company could be checked ends with the status Failed and the most common reason in its message, and the rows stay in the dataset.

An 8-K and a ticker that SEC does not list look like this:

```json
[
    {
        "status": "ok",
        "errorCode": null,
        "error": null,
        "input": "NKE",
        "cik": "0000320187",
        "ticker": "NKE",
        "companyName": "NIKE, Inc.",
        "form": "8-K",
        "isAmendment": false,
        "accessionNumber": "0000320187-26-000184",
        "filingDate": "2026-10-01",
        "reportDate": "2026-10-01",
        "acceptanceDateTime": "2026-10-02T00:15:15.000Z",
        "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/320187/000032018726000184/0000320187-26-000184-index.htm",
        "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320187/000032018726000184/nke-20261001.htm",
        "primaryDocDescription": "8-K",
        "fileNumber": "001-10635",
        "sizeBytes": 462141,
        "isXBRL": true,
        "isInlineXBRL": true,
        "items": [
            { "code": "2.02", "title": "Results of Operations and Financial Condition" },
            { "code": "2.05", "title": "Costs Associated with Exit or Disposal Activities" },
            { "code": "9.01", "title": "Financial Statements and Exhibits" }
        ],
        "itemCodes": ["2.02", "2.05", "9.01"],
        "itemsText": "2.02 Results of Operations and Financial Condition | 2.05 Costs Associated with Exit or Disposal Activities | 9.01 Financial Statements and Exhibits",
        "formD": null,
        "sic": "3021",
        "sicDescription": "Rubber & Plastics Footwear",
        "stateOfIncorporation": "OR",
        "exchange": "NYSE",
        "stateStore": "sec-edgar-monitor-a96837f88666afe40e68",
        "deliveredAt": "2026-10-12T17:16:38.812Z"
    },
    {
        "status": "not-found",
        "errorCode": "ticker-not-found",
        "error": "SEC's ticker list has no ticker ZZZZ. Check the spelling, or give the company's CIK. Not charged.",
        "input": "ZZZZ",
        "ticker": "ZZZZ",
        "companyName": null,
        "form": null,
        "accessionNumber": null
    }
]
```

The second row is shortened here. Every row carries every field, with `null` where a value does not apply, so exports keep the same columns.

### Tips for faster runs and lower costs

- Put all your companies in one list and one run. The start fee and the read of SEC's ticker list are paid once per run.
- A daily schedule catches every filing. The lookback window covers the days in between, so a missed run loses nothing and the next one delivers it.
- Keep only the form types you need. Fewer form types mean fewer charged rows.
- For a one-off backfill, raise `lookbackDays` for one run, then lower it again. Filings already delivered are never charged twice.
- Set `stateStoreName` before you start editing a list you run on a schedule, so the memory carries over.
- The Actor checks one company after another to stay inside SEC's limits. In our tests that took 0.5 to 0.9 seconds per company, so a list of 1,000 companies needs about 8 to 15 minutes. Give such a run a timeout of 30 minutes or more.

### FAQ, disclaimers and support

#### Is it legal to collect data from SEC EDGAR?

EDGAR filings are public records, and SEC publishes the submissions files this Actor reads for automated use. SEC asks automated tools to declare who they are and to stay under 10 requests a second. The Actor declares itself in every request and stays under 5. How you may use what you collect depends on your purpose and your country, so check that for your use case. This is general information, not legal advice.

#### Is this an official SEC tool?

No. The Actor is an independent tool. It is not made, endorsed or checked by the U.S. Securities and Exchange Commission. The data comes as filed: if a filer made a mistake, the row repeats it. Check the filing on sec.gov before you act on it.

#### Is personal data involved?

The Actor is built to collect company facts only. It refuses forms 3, 4, 5 and 144, which report one person's own trades and holdings. When a CIK belongs to a person who files as an insider, it skips the CIK and writes no name. From a Form D it reads the offering and leaves out the related persons, the sales agents, the signer and the issuer's street and phone. Some fields can still name people: a company or fund can carry a founder's name, and an 8-K item title such as 5.02 tells you that an officer changed (the row does not say who). Under the GDPR and similar laws you are the controller of what you collect, so keep and use it for a lawful reason.

#### What is a CIK and where do I find it?

The CIK (Central Index Key) is SEC's number for every filer. It is on each company's EDGAR page and in every filing. Use it for funds and private companies, which have no ticker, and for any company whose ticker changed.

#### Why did I not get a filing I can see on EDGAR?

Check four things: the form type is in your list (8-K/A needs **Include amendments**), the filing date is inside the lookback window, the filing was not already delivered to this list by an earlier run, and the company is the one you meant (the `cik` in `SUMMARY`). The window is counted on the filing date SEC assigns, which can be a day after the acceptance time for a filing sent late in the day.

#### How does the Actor know what is new, and how do I start over?

After each run it keeps the accession numbers of the filings it delivered in a named key-value store, listed in each row as `stateStore`. The next run with the same list skips them. To start over, delete that store under **Storage** in Console, or set a new `stateStoreName`. The memory forgets filings after 372 days, which no lookback can reach.

#### What happens when SEC limits the requests?

A "too many requests" answer (HTTP 429) is waited out, for as long as SEC's Retry-After header says and at most a minute, up to three times. A refusal (HTTP 403) gets one retry after 10 seconds. A second refusal stops all requests for the rest of the run, because SEC limits a busy address for a while. The companies the run did not reach get a `skipped` row with the code `sec-blocked`, nothing is charged for them, and the next run checks them.

#### What does unparsed mean?

The filing is new and delivered, with its links and dates, but the Form D details could not be read, so `formD` is empty. The row is not charged. When the cause is passing (`details-unavailable`), the next run delivers the filing again with its details, and charges it then. When the file itself is broken (`parse-failed`), the filing is not sent again.

#### What happens when a run reaches its time limit?

The Actor reads the time limit of the run from the platform and starts no new company in the last 30 seconds. Every company it did not reach gets a `skipped` row with the code `run-time-limit`, nothing is charged for them, and the next run checks them.

#### Can I send new filings to Slack, email or a spreadsheet?

Yes. Use Apify schedules for the runs, and integrations or webhooks to pass each run's dataset to Make, Zapier, Google Sheets, Slack or your own endpoint. Since each run holds only new filings, the dataset of a run is the alert.

#### What if something looks wrong?

Open the Issues tab on the Actor page and describe the companies, your input and what you expected. A run link helps. Issues are answered within two days.

### Other Actors by the same developer

- [SEC Form D Feed](https://apify.com/lone_rachis/sec-form-d-raises-feed): new private fundraising rounds filed with the SEC on Form D, with amounts and industry.
- [SEC XBRL Fundamentals](https://apify.com/lone_rachis/sec-xbrl-fundamentals): revenue, EPS, cash flow and other reported figures per company and period, from SEC XBRL filings.
- [UK Company Check](https://apify.com/lone_rachis/uk-company-check): Companies House status, outstanding charges and risk flags for UK companies, or a list of newly registered ones.
- [US Trademark Status and Watch](https://apify.com/lone_rachis/us-trademark-status-watch): USPTO status and upcoming deadlines for US trademarks, and what changed since your last run for marks you watch.
- [New Scholarly Papers Watch](https://apify.com/lone_rachis/scholarly-papers-watch): papers new since your last run for the keywords, ORCID authors, journals, funders or DOIs you watch, from Crossref.
- [Full Page Website Screenshot](https://apify.com/lone_rachis/full-page-website-screenshot): full-page PNG or JPEG screenshots, including pages that load content as you scroll.

# Actor input Schema

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

Companies to watch, one per line: a ticker such as AAPL or BRK.B, or a CIK (the SEC's company number) such as 320193 or CIK0000320193. Give the CIK for funds and private companies, which have no ticker. One run takes at most 1,000 companies. A ticker SEC does not list, or a CIK it has no filings for, gets one not-found row and costs nothing. The same company given twice is checked once.

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

EDGAR form types to return, written as EDGAR writes them: 8-K (current reports), 10-K and 10-Q (annual and quarterly reports), D (private offerings), S-1, 6-K, 20-F, DEF 14A and so on. 8-K rows carry their item codes with titles; Form D rows carry the offering amounts and industry. Forms 3, 4, 5 and 144 are refused, because they report one person's own trades and the Actor collects nothing about individuals. Changing this list starts a new memory unless you set a memory name below.

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

Also return amended versions of the chosen forms, such as 8-K/A for 8-K and D/A for D. An amendment is its own filing with its own accession number, so it is delivered and charged once like any other filing.

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

How many days back the first run reads, counted from today in UTC: 30 means filings dated on or after the day 30 days ago. Later runs read the same window and skip what they already delivered, so a schedule more frequent than this window never misses a filing. Raising it on a later run delivers the older filings it now reaches.

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

Optional. Name of the key-value store that remembers which filings were delivered. Leave it empty and the Actor makes a name from the companies and form types, so the same list always uses the same memory and a changed list starts fresh. Set a name to keep one memory while you add or remove companies. Lower-case letters, digits and hyphens, at most 63 characters. Delete the store in Storage to start again from the lookback.

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

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

## Actor input object example

```json
{
  "companies": [
    "AAPL",
    "MSFT",
    "NKE"
  ],
  "formTypes": [
    "8-K",
    "10-Q"
  ],
  "includeAmendments": true,
  "lookbackDays": 30
}
```

# Actor output Schema

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

Dataset with one row per new filing: status, company, form, dates, links, 8-K items and Form D details.

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

Counts of delivered, unparsed, not found, failed and skipped entries, the charged filings, the requests sent to SEC and the memory store used.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "AAPL",
        "MSFT",
        "NKE"
    ],
    "formTypes": [
        "8-K",
        "10-Q"
    ],
    "lookbackDays": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("lone_rachis/sec-edgar-filing-monitor").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",
        "NKE",
    ],
    "formTypes": [
        "8-K",
        "10-Q",
    ],
    "lookbackDays": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("lone_rachis/sec-edgar-filing-monitor").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",
    "NKE"
  ],
  "formTypes": [
    "8-K",
    "10-Q"
  ],
  "lookbackDays": 30
}' |
apify call lone_rachis/sec-edgar-filing-monitor --silent --output-dataset

```

## MCP server setup

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

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/xqPZ3WemCr3BgWAPN/builds/k9o8wCPo3mrUeM60I/openapi.json