# US Company Filings by Ticker: 10-K, 10-Q, 8-K, Form 4 (`ochinimus/us-company-filings`) Actor

Recent public filings from the SEC's EDGAR system for any US ticker: 10-K, 10-Q, 8-K, Form 4, S-1, 13F-HR and more, with filing date, accession number, 8-K item codes and links to the document and the filing index.

- **URL**: https://apify.com/ochinimus/us-company-filings.md
- **Developed by:** [Serghei Ochinca](https://apify.com/ochinimus) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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

## US Company Filings by Ticker: 10-K, 10-Q, 8-K, Form 4

**Recent public filings from the SEC's EDGAR system for any US-listed ticker, one clean JSON item per filing: form type, filing date, report date, accession number, description, 8-K item codes and links to the document and the filing index.**

Give the actor a list of tickers and, optionally, one form type. It reads each company's filing list from EDGAR at the moment you run it and returns the most recent filings, newest first. No scraping, no proxies, no HTML parsing, and no need to look up CIK numbers: the ticker is enough.

### What you get, per filing

- **Ticker, company name and CIK** of the filer.
- **Form type** (10-K, 10-Q, 8-K, 4, S-1, 13F-HR, DEF 14A and the rest of EDGAR's forms).
- **Filing date** and **report date** (the period or event date the filing reports on, where the form has one).
- **Accession number**, the identifier of the filing on EDGAR.
- **Description** of the primary document, as EDGAR lists it.
- **8-K item codes**, for example `2.02,9.01`, so you can tell an earnings release from a leadership change.
- **Links** to the primary document and to the filing's index page on sec.gov.
- `source` and `fetched_at` on every item.

### Use cases

- Watch a list of tickers for new 8-K filings and read the item codes to see what kind of event it is.
- Follow insider activity: pull the latest Form 4 filings for a ticker.
- Collect the latest 10-K and 10-Q links for a portfolio or a research list.
- Feed a bot, a spreadsheet or an alert on an Apify schedule, and export the results as JSON, CSV or Excel.
- Look up the accession number and document link for a known filing.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `tickers` | array of strings | prefill `["AAPL"]` | US-listed tickers (up to 50), for example `AAPL`, `MSFT`, `BRK-B`. Case does not matter. |
| `form` | string | none | Optional. One EDGAR form type, for example `10-K`, `10-Q`, `8-K`, `4`, `S-1`, `DEF 14A`, `13F-HR`. Empty means the most recent filings of any type. |
| `limit_per_ticker` | integer | `10` | How many of the most recent filings to return per ticker, 1 to 50. |

With no input at all, the actor returns the 10 most recent filings of `AAPL`, so the default run always returns data.

### How to run it

**In the Apify Console:** open the Actor, enter tickers (and a form type if you want one) in the Input tab and click Start. The dataset has an **Overview** table (one row per filing) and can be exported as JSON, CSV or Excel.

**Through the API:** one request starts a run and returns the items (replace `YOUR_API_TOKEN` with your Apify API token):

```bash
curl -X POST "https://api.apify.com/v2/acts/ochinimus~us-company-filings/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tickers": ["AAPL", "MSFT"], "form": "8-K", "limit_per_ticker": 5}'
```

The answer is a JSON array with one item per filing. See the Apify API docs for asynchronous runs and schedules.

### Sample output

Two real results, captured live on 14 Oct 2026 (an insider Form 4 and an 8-K with item codes).

```json
[
  {
    "ticker": "AAPL",
    "company": "Apple Inc.",
    "cik": "0000320193",
    "form": "4",
    "filing_date": "2026-10-08",
    "report_date": "2026-10-06",
    "accession_number": "0001140361-26-039158",
    "description": "FORM 4",
    "items": null,
    "document_url": "https://www.sec.gov/Archives/edgar/data/320193/000114036126039158/xslF345X06/form4.xml",
    "index_url": "https://www.sec.gov/Archives/edgar/data/320193/000114036126039158/0001140361-26-039158-index.htm",
    "source": "SEC EDGAR (public)",
    "fetched_at": "2026-10-14T16:16:40.290Z"
  },
  {
    "ticker": "AAPL",
    "company": "Apple Inc.",
    "cik": "0000320193",
    "form": "8-K",
    "filing_date": "2026-07-30",
    "report_date": "2026-07-30",
    "accession_number": "0000320193-26-000018",
    "description": "8-K",
    "items": "2.02,9.01",
    "document_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/aapl-20260730.htm",
    "index_url": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000018/0000320193-26-000018-index.htm",
    "source": "SEC EDGAR (public)",
    "fetched_at": "2026-10-14T16:16:44.458Z"
  }
]
```

### Pricing

Pay per event: **$0.002 per filing returned** (event `filing`), plus Apify's tiny per-run start fee.

You are charged only for filings that come back. A ticker that is not in the SEC's company ticker list, a form type the company has never filed, a form with no filings, and any data-source error return nothing and cost nothing.

### Data source and its limits

- **Source: public filings from the SEC's EDGAR system (sec.gov), through AgentFeed (x402.ochinimus.app).** EDGAR is public: its filings are free to access and reuse. Every item carries the source line `SEC EDGAR (public)`.
- **Not affiliated with or endorsed by the U.S. Securities and Exchange Commission (SEC).**
- **Metadata and links, not filing text.** You get the filing's date, form, description and links; open the document link for the content.
- **US-listed tickers only**, as listed in the SEC's company ticker list. Foreign private issuers file different forms (for example 6-K and 20-F), so use the `form` field accordingly.
- **Most recent first, up to 50 per ticker.** The list is read from EDGAR at request time, so it is as current as EDGAR's own publication.
- A form type that is not a common EDGAR form and that the company has never filed is treated as a typo and returns nothing.
- EDGAR limits how fast it can be queried, and the data source stays under that limit, so a very large input is processed one ticker at a time and takes a little longer.
- This is data, not advice, and you are responsible for how you use it.

### Built for agents too

The same data is sold per call to AI agents over the x402 protocol (USDC, no account): [x402.ochinimus.app](https://x402.ochinimus.app), route `/api/sec-filings`, OpenAPI at [x402.ochinimus.app/openapi.json](https://x402.ochinimus.app/openapi.json).

Source code: [github.com/seekdaseek/agentfeed-apify](https://github.com/seekdaseek/agentfeed-apify) (MIT), folder `us-company-filings`.

# Actor input Schema

## `tickers` (type: `array`):

US-listed tickers, one per line, e.g. AAPL, MSFT or BRK-B (up to 50). Every filing found is one result. A symbol that is not in the SEC's company ticker list returns nothing and is not charged.

## `form` (type: `string`):

Optional. Return only this EDGAR form type, for example 10-K, 10-Q, 8-K, 4, S-1, DEF 14A or 13F-HR. Leave empty for the most recent filings of any type.

## `limit_per_ticker` (type: `integer`):

How many of the most recent filings to return for each ticker, 1 to 50. Every filing returned is one charged result.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "limit_per_ticker": 10
}
```

# Actor output Schema

## `overview` (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 = {
    "tickers": [
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ochinimus/us-company-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 = { "tickers": ["AAPL"] }

# Run the Actor and wait for it to finish
run = client.actor("ochinimus/us-company-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 '{
  "tickers": [
    "AAPL"
  ]
}' |
apify call ochinimus/us-company-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ochinimus/us-company-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/qG8Yla4xrDfudEdfa/builds/6o2hp7708tcyET7yY/openapi.json