# SEC EDGAR Filings & Insider Trading API (`dobus/sec-filing-events-insider-signals`) Actor

Fetch official SEC EDGAR filings, 10-K, 10-Q, 8-K, Form 4 insider trading disclosures, ticker-to-CIK lookup, transaction-code filters, company facts, and JSON for AI agents.

- **URL**: https://apify.com/dobus/sec-filing-events-insider-signals.md
- **Developed by:** [Afonso Fernandes](https://apify.com/dobus) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## 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 Filings & Insider Trading API

Fetch official SEC EDGAR filings and Form 4 insider trading disclosures as clean JSON dataset items. Use it as a SEC EDGAR API for 10-K, 10-Q, 8-K, Form 4, ticker-to-CIK lookup, company filing monitoring, AI agents, spreadsheets, and financial data pipelines.

The Actor reads public SEC data, resolves tickers to CIKs, returns recent filing events, and can parse Form 4 insider transactions into structured rows with source URLs. It does not provide investment, legal, tax, or financial advice.

### What It Does

- Gets SEC EDGAR company filings from official SEC endpoints.
- Resolves ticker symbols such as AAPL, MSFT, NVDA, and TSLA to SEC CIKs.
- Filters by form type, including 10-K, 10-Q, 8-K, S-1, 13F, and Form 4.
- Returns filing date, report date, accession number, form type, primary document, archive URL, and evidence URL.
- Optionally parses Form 4 XML into insider transaction rows with owner, role, transaction code, shares, price, gross value, and source URL.
- Optionally adds selected XBRL company facts.
- Writes one normalized result per item to the default dataset for API, CSV, Excel, Make, Zapier, n8n, Airtable, databases, or AI agents.

### Who It Is For

- Financial developers building SEC data workflows.
- Researchers and analysts monitoring public company filings.
- Fintech applications that need filing metadata or insider transaction rows.
- AI agents that need evidence-linked SEC data.
- Automation developers building alerts, scheduled jobs, or dashboards.
- Data teams feeding warehouses, spreadsheets, or internal research tools.

### Use Cases

- Monitor new SEC filings for a watchlist of tickers.
- Retrieve latest 10-K annual reports.
- Retrieve latest 10-Q quarterly reports.
- Monitor 8-K current report events.
- Track Form 4 insider transactions.
- Detect insider purchases and sales as filed with the SEC.
- Build structured financial filing datasets.
- Feed SEC data into AI agents with source evidence.
- Build automated company monitoring.
- Research historical recent filings by ticker or CIK.

### Example Input

```json
{
  "tickers": ["AAPL"],
  "forms": ["4", "8-K", "10-Q", "10-K"],
  "limit": 10,
  "includeForm4Details": true,
  "transactionCodes": ["S"],
  "includeCompanyFacts": false
}
```

### Example Filing Output

```json
{
  "recordType": "filing",
  "company": {
    "cik": "0000320193",
    "ticker": "AAPL",
    "name": "Apple Inc.",
    "sic": "3571"
  },
  "form": "4",
  "filingDate": "2026-08-13",
  "reportDate": "2026-08-11",
  "accessionNumber": "0001140361-26-032884",
  "filingDetailUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126032884",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126032884/xslF345X06/form4.xml"
}
```

### Example Form 4 Transaction Fields

When `includeForm4Details` is enabled and a Form 4 document contains transaction rows, the dataset can also include:

- `recordType`: `insiderTransaction`
- `issuerTradingSymbol`
- `ownerName`
- `officerTitle`
- `transactionDate`
- `transactionCode`
- `acquiredDisposedCode`
- `shares`
- `pricePerShare`
- `grossValue`
- `sharesOwnedFollowingTransaction`
- `sourceUrl`

Use `transactionCodes` to keep only specific Form 4 codes, for example `["P"]` for open-market purchases or `["S"]` for sales. Leave it empty to return all parsed Form 4 transactions.

### Ready-to-Run Examples

- [Track Apple SEC Filings](https://apify.com/dobus/sec-filing-events-insider-signals/examples/track-apple-sec-filings)
- [Monitor Tesla SEC Filings](https://apify.com/dobus/sec-filing-events-insider-signals/examples/monitor-tesla-sec-filings)
- [Find Recent Form 4 Insider Transactions](https://apify.com/dobus/sec-filing-events-insider-signals/examples/recent-form-4-insider-transactions)
- [Get Latest 10-K Filings](https://apify.com/dobus/sec-filing-events-insider-signals/examples/latest-10-k-filings)
- [Get Latest 10-Q Filings](https://apify.com/dobus/sec-filing-events-insider-signals/examples/latest-10-q-filings)
- [Monitor 8-K Events](https://apify.com/dobus/sec-filing-events-insider-signals/examples/monitor-8-k-events)
- [Track Insider Purchases](https://apify.com/dobus/sec-filing-events-insider-signals/examples/track-insider-purchases)
- [Track Insider Sales](https://apify.com/dobus/sec-filing-events-insider-signals/examples/track-insider-sales)
- [Get SEC Filings by Ticker](https://apify.com/dobus/sec-filing-events-insider-signals/examples/get-sec-filings-by-ticker)
- [SEC EDGAR Data for AI Agents](https://apify.com/dobus/sec-filing-events-insider-signals/examples/sec-edgar-data-for-ai-agents)

### API Usage

#### REST

```http
POST https://api.apify.com/v2/acts/dobus~sec-filing-events-insider-signals/runs?token=YOUR_APIFY_TOKEN
Content-Type: application/json

{
  "tickers": ["TSLA"],
  "forms": ["4"],
  "limit": 10,
  "includeForm4Details": true,
  "transactionCodes": ["P"]
}
```

Read results from the run's `defaultDatasetId`:

```http
GET https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("dobus/sec-filing-events-insider-signals").call(run_input={
    "tickers": ["AAPL"],
    "forms": ["4", "8-K", "10-Q", "10-K"],
    "limit": 10,
    "includeForm4Details": True,
    "transactionCodes": ["S"],
})

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(items[:3])
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });
const run = await client.actor("dobus/sec-filing-events-insider-signals").call({
  tickers: ["MSFT"],
  forms: ["10-K", "10-Q", "8-K"],
  limit: 10,
  includeForm4Details: false
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

#### curl

```bash
curl -X POST "https://api.apify.com/v2/acts/dobus~sec-filing-events-insider-signals/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tickers":["BAC"],"forms":["4"],"limit":8,"includeForm4Details":true,"transactionCodes":["P"]}'
```

#### MCP / AI Agents

Use the Apify MCP server and expose this Actor as a tool:

```json
{
  "mcpServers": {
    "apify-sec-edgar": {
      "url": "https://mcp.apify.com?tools=dobus/sec-filing-events-insider-signals",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Good agent prompts:

- "Get the latest Form 4 filings for AAPL and return insider transaction rows with source URLs."
- "Monitor TSLA 8-K filings and summarize only the filing metadata, not investment advice."
- "Fetch recent 10-K and 10-Q filings for MSFT as structured JSON."

### Pricing

- Actor start: USD 0.01 per run.
- Result: USD 0.002 per default dataset item.

Example: a run that returns 10 dataset items costs USD 0.01 + 10 x USD 0.002 = USD 0.03, plus any Apify platform usage shown by Apify.

The source SEC data is public and free. Pricing covers normalization, parsing, rate limiting, retries, evidence links, dataset output, and maintenance.

### FAQ

#### Is this a SEC EDGAR API?

Yes. It is an Apify Actor that can be run through the Apify API, schedules, integrations, or MCP. It returns SEC EDGAR data as structured JSON dataset items.

#### Does it cover Form 4 insider trading?

Yes. Use `forms: ["4"]` and enable `includeForm4Details` to parse available Form 4 XML documents into insider transaction rows. Use `transactionCodes` when you only want specific codes such as `P` or `S`.

#### Does it return investment recommendations?

No. It returns public filings and source URLs only. It does not score stocks, predict returns, or recommend trades.

#### Does it use official SEC data?

Yes. It uses SEC ticker/CIK mapping, company submissions, filing documents, and optional company facts from public SEC endpoints.

#### Can I run it on a schedule?

Yes. Save an Apify task with your watchlist and schedule it hourly, daily, or weekly.

#### What should an AI agent use this for?

Use it when the agent needs recent SEC filings, 10-K, 10-Q, 8-K, Form 4 insider transactions, ticker-to-CIK lookup, or evidence-linked public company filing data.

### Troubleshooting

- Empty dataset: widen `forms`, increase `limit`, or remove `since`.
- No Form 4 transaction rows: the filing may not have parsable transaction rows, or `includeForm4Details` may be disabled.
- No purchase or sale rows: remove `transactionCodes` or use a broader ticker/date range.
- Invalid ticker: use a CIK directly if the ticker is ambiguous or newly listed.
- Slow run: lower `maxCompanies`, lower `limit`, or keep `requestsPerSecond` conservative.

### Compliance

This Actor returns public SEC data and source links. It is not investment, legal, tax, or financial advice. Always verify source filings before relying on the data.

# Actor input Schema

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

Public company stock tickers to look up in SEC EDGAR, for example AAPL, MSFT, NVDA, or TSLA. Provide tickers, CIKs, or both.

## `ciks` (type: `array`):

SEC Central Index Key identifiers for exact company lookup. Use this when an AI agent or data pipeline already knows the CIK.

## `forms` (type: `array`):

SEC form types to return, such as 4 for Form 4 insider transactions, 8-K for current reports, 10-Q for quarterly reports, and 10-K for annual reports.

## `limit` (type: `integer`):

Maximum SEC filings returned for each company before optional Form 4 transaction parsing.

## `since` (type: `string`):

Optional earliest SEC filing date in YYYY-MM-DD format, for example 2026-01-01.

## `includeForm4Details` (type: `boolean`):

Fetch and parse SEC Form 4 XML documents into insider transaction rows with owner, role, transaction code, shares, price, gross value, and source URL.

## `transactionCodes` (type: `array`):

Optional Form 4 transaction codes to keep after parsing, such as P for open-market purchase or S for sale. Leave empty to return all parsed Form 4 transactions.

## `includeCompanyFacts` (type: `boolean`):

Fetch selected SEC XBRL company facts for each company, useful for enrichment and AI-agent context.

## `maxCompanies` (type: `integer`):

Safety limit for the number of companies processed in a single run.

## `requestsPerSecond` (type: `number`):

Rate limit for SEC EDGAR requests. Keep this conservative to respect SEC fair-access expectations.

## `secUserAgent` (type: `string`):

Identifiable SEC User-Agent with contact email. If omitted, the Actor uses the owner-configured SEC\_USER\_AGENT secret.

## `healthCheck` (type: `boolean`):

Validate that the Actor starts correctly without calling SEC. Leave off for normal runs.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "forms": [
    "4",
    "8-K",
    "10-Q",
    "10-K"
  ],
  "limit": 20,
  "includeForm4Details": true,
  "includeCompanyFacts": false,
  "maxCompanies": 10,
  "requestsPerSecond": 8,
  "healthCheck": false
}
```

# Actor output Schema

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

Default dataset containing one item per normalized SEC EDGAR filing event or parsed Form 4 insider transaction.

# 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("dobus/sec-filing-events-insider-signals").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("dobus/sec-filing-events-insider-signals").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 dobus/sec-filing-events-insider-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dobus/sec-filing-events-insider-signals"
        }
    }
}

```

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/HLa6CdAvVod8GSxDp/builds/snEsga3vlvVrDCkqy/openapi.json