# Filing Events API - SEC, FDA, NIH & Congress, One Schema (`datasignalslab/filing-events-api`) Actor

Twelve streams of US filings and career-site events in one record shape: insider clusters, Form 144, 13D/G, 13F, 8-K, Form D, FDA, trial readouts, NIH grants, federal contracts, congressional trades and hiring signals. Every record carries its score inputs and a proof reference.

- **URL**: https://apify.com/datasignalslab/filing-events-api.md
- **Developed by:** [DataSignals Lab](https://apify.com/datasignalslab) (community)
- **Categories:** AI, News, Agents
- **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 events

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Filing Events API: twelve US filing streams in one schema

Twelve streams of US filings and career-site events in **one record shape**, so you
write one parser instead of twelve.

**Run it with no input to see it work.**

### Why this exists next to the single-source Actors

The individual Actors in this account each read one source and return that source's
own shape. This one returns all twelve in the same envelope, with the score inputs,
the formula version and a proof reference on every record. If you are pulling more
than one stream, this is the one you want.

### The twelve streams

| event\_type | publisher |
|---|---|
| `insider_cluster` | SEC EDGAR |
| `insider_sale_notice` | SEC EDGAR |
| `activist_stake` | SEC EDGAR |
| `institutional_holding` | SEC EDGAR |
| `material_event` | SEC EDGAR |
| `private_raise` | SEC EDGAR |
| `fda_action` | openFDA |
| `biotech_catalyst` | ClinicalTrials.gov |
| `nih_grant` | NIH RePORTER |
| `gov_contract_award` | USAspending.gov |
| `congress_trade` | U.S. House Clerk |
| `hiring_signal` | company career sites |

### What a record carries

`event_type`, `company`, `occurred_at`, `filed_at`, `source`, `data` (the fields
specific to that stream), `score`, `score_label`, `score_inputs`, `scored_on`,
`proof` and `_cursor`.

**If an input is missing from the source, the record says so** rather than guessing.
A score you cannot recompute is a number you cannot defend.

### Cursor

Every run reports the last `_cursor` it delivered. Pass it back as **Since cursor**
next time and you get only what is new: no duplicates, no gaps, however often you
run it.

### Honest limits

**Not real time.** Sources refresh once a night, and some publishers are slower by
nature: congressional trades are weekly, institutional holdings quarterly. The run
log prints the delay on the feed it used.

**First call after a quiet period.** The upstream service sleeps when nobody is
using it and answers `starting_up` once. This Actor retries that by itself, so you
only notice it as a slower first run.

**Scores are opinions with their working shown.** Not investment advice. The formula
version is on every record so you can disagree with it precisely.

### Pricing

Pay per event delivered. A run that returns nothing costs nothing.

# Actor input Schema

## `eventTypes` (type: `array`):

Leave empty for every stream. Pick one or more to narrow it down; they are fetched in a single upstream call. You pay per event delivered.

## `ticker` (type: `string`):

Leave empty for every company. A ticker such as META or BSX; the upstream field is called ticker, and an unknown one returns nothing rather than everything.

## `sinceCursor` (type: `integer`):

Pass back the cursor from your previous run to get only what is new. Cursor-based, so no duplicates and no gaps however often you run it. Leave at 0 for the most recent events.

## `maxEvents` (type: `integer`):

Hard stop. You pay per event delivered, so this is also your budget cap.

## `minScore` (type: `integer`):

Keep only events scored at or above this. Note that not every stream is scored; unscored events are dropped when this is above 0.

## Actor input object example

```json
{
  "eventTypes": [
    "activist_stake"
  ],
  "ticker": "",
  "sinceCursor": 0,
  "maxEvents": 100,
  "minScore": 0
}
```

# Actor output Schema

## `events` (type: `string`):

One row per event, in the same shape across all twelve streams: stream, company, when it happened, when it was filed, the score with its inputs, and a proof reference.

# 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 = {
    "eventTypes": [
        "activist_stake"
    ],
    "maxEvents": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasignalslab/filing-events-api").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 = {
    "eventTypes": ["activist_stake"],
    "maxEvents": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("datasignalslab/filing-events-api").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 '{
  "eventTypes": [
    "activist_stake"
  ],
  "maxEvents": 100
}' |
apify call datasignalslab/filing-events-api --silent --output-dataset

```

## MCP server setup

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

```

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/2n8kvNgflLLn629FJ/builds/rcHXsrApXAZH8dMQY/openapi.json