# SEC EDGAR Filings Feed (`your_friendly_developer/sec-edgar-filings-feed`) Actor

Returns the latest SEC EDGAR filings for the form types you choose (8-K, S-1, 4, 10-Q and more), one normalized row per filing.

- **URL**: https://apify.com/your_friendly_developer/sec-edgar-filings-feed.md
- **Developed by:** [Jason Ramirez](https://apify.com/your_friendly_developer) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 filing rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## SEC EDGAR Filings Feed

Get the latest SEC EDGAR filings for the form types you care about (8-K, S-1, 4, 10-Q, 13D and more) as clean, normalized rows: one row per filing, with accession number, form type, company name, CIK, filing timestamp and a link to the filing index.

### Who it is for

- **Investors and analysts** who want new 8-Ks, Form 4 insider trades or S-1s as soon as they land.
- **Journalists** watching for material events and new registrations.
- **Compliance teams** monitoring filings by counterparties or portfolio companies.
- **Lead and sales teams** that use new filings (IPOs, financings, executive changes) as buying signals.

### How it works

For each form type you request, the Actor reads EDGAR's public "latest filings" Atom feed:

```
https://www.sec.gov/cgi-bin/browse-edgar?action=getcurrent&type={FORM}&count={n}&output=atom
```

It parses each feed entry, normalizes it into one row, removes duplicates by accession number (the same filing can appear under two requested types, and Form 4 filings appear once for the reporting person and once for the issuer), and pushes the rows to the dataset. It never fetches the filing documents themselves.

### SEC fair access and why you must give a contact

EDGAR is free and needs no API key, but the SEC's fair-access policy asks automated tools to:

1. Declare who they are in the `User-Agent` header, with a company or name and a contact email.
2. Stay at or below 10 requests per second.

That is why `userAgentContact` is a **required** input. It is sent as `User-Agent: EDGAR Filings Feed {your contact}`. Placeholder addresses such as `example.com` are rejected, because the point of the header is that the SEC can reach a real person if a tool misbehaves. Requests without a proper declaration may be blocked by the SEC.

The Actor makes one request per form type, sequentially, with a 150 ms pause between requests, so a run with the maximum 10 form types makes 10 requests, far under the limit.

### Input

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `formTypes` | array of strings | yes | | 1 to 10 form types, for example `["8-K", "S-1", "4", "10-Q"]`. |
| `countPerType` | integer | no | 40 | Latest filings requested per form type. Maximum 100 (EDGAR's cap). |
| `userAgentContact` | string | yes | | Your name or company plus a real contact email, for example `Acme Research ops@acme.com`. |

#### Examples

Material events and insider trades:

```json
{
    "formTypes": ["8-K", "4"],
    "countPerType": 100,
    "userAgentContact": "Acme Research ops@acme.com"
}
```

New registrations and quarterly reports:

```json
{
    "formTypes": ["S-1", "10-Q"],
    "userAgentContact": "Jane Doe jane.doe@newsroom.org"
}
```

### Output

One dataset item per filing:

| Field | Type | Description |
| --- | --- | --- |
| `accessionNumber` | string or null | SEC accession number, `NNNNNNNNNN-YY-NNNNNN`. Taken from the filing index URL or the entry id. `null` if neither contains one; the Actor never guesses. |
| `formType` | string or null | Form type as shown in the feed entry title, for example `8-K` or `10-K/A`. |
| `companyName` | string or null | Company or person name from the entry title. |
| `cik` | string or null | Central Index Key, zero-padded to 10 digits. |
| `filedAt` | string or null | The entry's `updated` timestamp from the feed (falls back to `published`). |
| `filingIndexUrl` | string or null | Link to the filing index page on sec.gov. |
| `filingDetailUrl` | string or null | Same as `filingIndexUrl`. Filing documents are not fetched. |
| `source` | string | Always `SEC EDGAR`. |

Example row:

```json
{
    "accessionNumber": "0001111111-26-000101",
    "formType": "8-K",
    "companyName": "ACME WIDGETS INC",
    "cik": "0001111111",
    "filedAt": "2026-11-14T17:25:01-05:00",
    "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1111111/000111111126000101/0001111111-26-000101-index.htm",
    "filingDetailUrl": "https://www.sec.gov/Archives/edgar/data/1111111/000111111126000101/0001111111-26-000101-index.htm",
    "source": "SEC EDGAR"
}
```

#### Run summary

Each run stores a `LAST_RUN_SUMMARY` record in the default key-value store:

```json
{
    "runAt": "2026-11-15T12:00:00.000Z",
    "requestedTypes": ["8-K", "4"],
    "emitted": 4,
    "failedTypes": [],
    "notes": ["2 duplicate filings removed by accessionNumber."]
}
```

If one form type's feed fails (HTTP error, network error, or a response that is not an Atom feed), it is listed in `failedTypes` with a note, and the other form types still run. The run is marked failed only if every requested type fails.

### Pricing model

Pay per event: one `filing` event is charged per row pushed to the dataset. Rows are only produced for filings the feed actually returned.

### Honest limits

- **Snapshot, not history.** The feed shows the latest filings at the moment of the query. This is not a historical or full-text search. To track filings over time, schedule the Actor and dedup on `accessionNumber` downstream.
- **Up to 100 per form type.** EDGAR caps the feed at 100 entries per request; busy form types (such as 4 or 8-K) can produce more than 100 filings in a short period, so a single run can miss older ones.
- **EDGAR's type matching.** The feed's `type` filter is applied by EDGAR, which may also return related forms (for example amendments such as `8-K/A` when asking for `8-K`). `formType` reports what the feed entry says.
- **Field shapes come from the feed.** If the SEC changes the feed format, affected fields come back as `null` rather than invented values.
- **No document content.** Only metadata and links; the filing documents themselves are not downloaded.

### Run locally

Requires Node.js 20 or newer.

```bash
cd sec-edgar-filings-feed
npm install
npm test            # offline unit tests, no network

## Local run with the Apify CLI:
## put your input in storage/key_value_stores/default/INPUT.json, then
apify run
```

The tests use fixture Atom feeds and an injected fake `fetch`, so they never touch the network.

# Actor input Schema

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

SEC form types to fetch from the EDGAR latest filings feed, for example 8-K, S-1, 4, 10-Q. Between 1 and 10 entries.

## `countPerType` (type: `integer`):

How many of the latest filings to request per form type. EDGAR caps this at 100.

## `userAgentContact` (type: `string`):

Required. SEC fair-access rules ask automated clients to declare who they are with a company name and contact email, for example "Acme Research ops@acme.com". It is sent as the User-Agent "EDGAR Filings Feed {your contact}". Placeholder example.com addresses are rejected.

## Actor input object example

```json
{
  "formTypes": [
    "8-K"
  ],
  "countPerType": 40,
  "userAgentContact": "Your Friendly Developer hello@yourfriendlydeveloper.com"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing one normalized row per filing

## `keyValueStore` (type: `string`):

Default key-value store holding the LAST_RUN_SUMMARY record

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "formTypes": [
        "8-K"
    ],
    "userAgentContact": "Your Friendly Developer hello@yourfriendlydeveloper.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("your_friendly_developer/sec-edgar-filings-feed").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "formTypes": ["8-K"],
    "userAgentContact": "Your Friendly Developer hello@yourfriendlydeveloper.com",
}

# Run the Actor and wait for it to finish
run = client.actor("your_friendly_developer/sec-edgar-filings-feed").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "formTypes": [
    "8-K"
  ],
  "userAgentContact": "Your Friendly Developer hello@yourfriendlydeveloper.com"
}' |
apify call your_friendly_developer/sec-edgar-filings-feed --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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