# SEC 13D/G Activist Stake Monitor - Stakes & Intent Signals (`datasignalslab/sec-13dg-activist-stake-monitor`) Actor

SEC 13D/13G activist stake monitor: who takes a 5%+ stake, activist vs passive, with filer and impact score. Pay per company.

- **URL**: https://apify.com/datasignalslab/sec-13dg-activist-stake-monitor.md
- **Developed by:** [DataSignals Lab](https://apify.com/datasignalslab) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $200.00 / 1,000 company analyzeds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 13D/13G Activist Stake Monitor: Who Is Taking a 5%+ Position

**See who is taking a 13D activist stake in a company, and whether they mean to shake it up.** Give one or more tickers and get their recent Schedule 13D and 13G filings from the SEC EDGAR submissions API, each one classified and scored: activist (13D, intent to influence) versus passive (13G), new stake versus amendment, with the filer named and a direct link to the document. This is not a raw filing dump. It is the 13D activist stake signal, ranked.

When an investor crosses 5% beneficial ownership and files a Schedule 13D, it signals intent to influence the company, the kind of event that can move a stock. A 13G, by contrast, is a passive 5%+ holding. This Actor surfaces those 13D/13G filings per company, separates activist intent from passive ownership, and tells you who is buying whom.

**Real example (from live data):** GME top filing was a new Schedule 13D scored impact 88. Direction: outbound, meaning GameStop itself disclosed an activist stake in eBay. Inbound on GME: RC Ventures / Ryan Cohen 13D/A amendments. Highest-impact filings rank first.

### Why this is different

Most EDGAR scrapers return raw filing rows and leave interpretation to you. This Actor computes the signal layer an activist investor monitor actually needs:

- **Activist versus passive classification.** A Schedule 13D (a 5% stake with intent to influence) is scored far above a passive 13G holding. The split is explicit in every record via an `is_activist` flag, so you never guess intent from a form code.
- **Impact score, not raw filings.** Each event gets one 0-100 impact score blending filing type and recency. A brand-new activist 13D this month rises to the top, while a routine passive amendment sinks. You read a ranked list, not 60 undifferentiated rows.
- **Direction.** Each filing is tagged inbound (someone is taking a stake IN this company) or outbound (this company is itself taking a stake in another). The inbound activist filing is usually the real signal.
- **Filer identification.** The actual holder is pulled from the filing header (for example RC Ventures LLC), not left as an anonymous "a 13D".
- **The activist's stated purpose.** For 13D filings, the Actor extracts Item 4 ("Purpose of Transaction") - the activist's own words on what they want: board seats, a strategic review, a sale, capital returns. This is the part of the filing professionals actually read, delivered as a `purpose` field on every activist record.

### Who it's for

- **Event-driven traders and quants.** A ready-made 13D activist stake feed for screening and research, with activist intent already separated from passive ownership.
- **Fintech and research apps.** Drop classified 13D/13G stake signals straight into your product or dataset pipeline.
- **Competitive-intelligence teams.** Track who is accumulating a 5%+ position in a company you care about, and whether they filed as an activist or a passive holder.

It pairs with the wider SEC suite (Form 4 insider, 13F, and 8-K Actors) for a full market-catalyst toolkit.

### Use cases

- **Activist alerts on a watchlist.** Scan a list of tickers and surface only fresh, high-impact 13D filings to catch new activist campaigns early.
- **Event-driven backtesting input.** Pull historical 13D/13G filings per company, with dates and impact scores, as labeled events.
- **Holder discovery.** Identify the fund or individual behind a 5%+ stake from the filer name parsed in the header.
- **Activist-only screening.** Filter out passive 13G ownership noise and keep only activist intent above a chosen impact threshold.
- **Competitive monitoring.** Watch whether rivals or strategic acquirers are building positions in a target company.

### Input

| Field | Type | Description |
|---|---|---|
| `tickers` | array | One or more US tickers (e.g. GME, AAPL, TSLA) or 10-digit SEC CIK numbers. Required. Each is scanned for recent Schedule 13D/13G stake filings. |
| `maxFilings` | integer | How many of the company's most recent 13D/13G filings to classify and rank per company. Default 25, range 1 to 60. |
| `minImpact` | integer | Only return filings at or above this impact score (e.g. 70 = activist-grade only). Default 0 (all), range 0 to 100. |
| `onlyInbound` | boolean | If on, return only stakes taken IN the company (inbound), hiding outbound filings where the company itself takes a stake elsewhere. Default false. |

### Output

One dataset item per company: the query, the resolved company name, the number of filings found, an activist (13D) count, a high-impact count, and a ranked list of filings. Each filing carries the form, filing date, holder (filer), target company (subject), direction, activist and amendment flags, a best-effort stake percent, the Item 4 purpose text for activist 13Ds, the catalyst description, an impact score, and a direct SEC.gov URL.

```json
{
  "type": "activist_filings",
  "query": "GME",
  "company": "GameStop Corp.",
  "filings_found": 12,
  "activist_count": 7,
  "high_impact_count": 3,
  "filings": [
    {
      "subject": "eBay Inc.",
      "ticker": "GME",
      "filer": "GameStop Corp.",
      "form": "SC 13D",
      "is_activist": true,
      "is_amendment": false,
      "filing_date": "2026-05-20",
      "percent": "",
      "purpose": "The Reporting Person believes that the Issuer's Common Stock is undervalued and represents an attractive investment opportunity...",
      "catalyst": "New activist stake (13D) - investor with intent to influence",
      "direction": "outbound",
      "impact": 88,
      "accession": "0001234567-26-000123",
      "url": "https://www.sec.gov/Archives/edgar/data/1326380/000123456726000123/"
    }
  ]
}
````

### How the impact score works

The score is transparent and computed directly from the filing, with no hidden model. It starts from a base value per filing type, where activist filings outrank passive ones:

- New Schedule 13D (activist, intent to influence): base 80
- Schedule 13D/A (activist position or intent updated): base 60
- New Schedule 13G (passive 5%+ holding): base 35
- Schedule 13G/A (passive holding updated): base 20

A recency bonus is then added, because a stake being built now is a stronger signal than an old one: +15 if the filing is 30 days old or less, +8 if it is 90 days old or less. The result is capped at 100. A brand-new activist 13D filed this month can reach the high-80s to mid-90s, while a months-old passive amendment stays low. Set `minImpact` to 70 to keep only activist-grade events.

### Use with AI agents and automation

This Actor is built to be called by software, not just clicked in a dashboard.

- **AI agents and LLM frameworks.** Call it from LangChain or LlamaIndex as a tool, or expose it through the Apify MCP server so assistants like Claude, ChatGPT, or Cursor can run it and read the classified 13D/13G results directly in a conversation.
- **No-code automation.** Wire it into Zapier or Make to trigger downstream steps when a new activist stake appears.
- **Webhooks.** Fire an Apify webhook on run completion to push fresh filings into your own service.
- **JSON on demand or on a schedule.** Run it ad hoc for a one-off scan, or schedule recurring runs over a watchlist and consume the dataset as JSON.

### Pricing

**Pay-per-event: one charge per company analyzed.** Scan a 10-ticker watchlist and you pay for 10 companies. There is no subscription and no monthly minimum. You pay only for what you scan, whether a single company or a full watchlist.

### Data source and compliance

Data comes from the official SEC EDGAR submissions API (data.sec.gov), which is free, public, and requires no key. The Actor maps each ticker to its CIK, filters the 13D/13G filings, then reads each filing header to identify the holder and classify activist versus passive and new versus amendment. All of this is public regulatory disclosure that filers are legally required to submit. The Actor reads no personal data beyond the company and filer names already on the public record, and it links every result back to the source document on SEC.gov for verification.

### FAQ

**What is the difference between a Schedule 13D and a 13G?** A Schedule 13D is filed by a holder who has crossed 5% beneficial ownership and intends to influence the company, so it signals activist intent. A 13G is filed by a passive 5%+ holder, often an index fund or a long-term investor with no intent to control. The Actor separates the two with an explicit `is_activist` flag.

**What does the "/A" suffix mean?** It marks an amendment to an earlier filing. A 13D/A updates a prior 13D and a 13G/A updates a prior 13G. New filings are scored above amendments.

**Can an AI agent call this automatically?** Yes. Expose the Actor through the Apify MCP server and an AI agent such as Claude, ChatGPT, or Cursor can call it on its own, pass tickers, and read back the classified, scored 13D/13G filings. It also works as a LangChain or LlamaIndex tool.

**Which companies can I track?** Any US-listed company with a ticker in SEC EDGAR, or any company referenced by its 10-digit CIK number.

**Why is the stake percent sometimes empty?** The percent is pulled best-effort from the filing cover page. Filing formats vary, so when the value cannot be parsed cleanly the field degrades to empty rather than guessing. Form type, filer, date, and impact score are always populated.

***

*Keywords: 13D activist stake, Schedule 13D 13G, activist investor monitor, 5% stake, SEC 13D filing, beneficial ownership, SEC EDGAR API, activist campaign, event-driven trading, hedge fund stakes, activist stake data, investor intent signal.*

***

**Note:** Provided as data for research, screening, and monitoring, not investment advice. Historical patterns do not guarantee future results.

# Actor input Schema

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

One or more US stock tickers (e.g. GME, AAPL, TSLA) or 10-digit SEC CIK numbers. Each is scanned for recent Schedule 13D/13G stake filings.

## `maxFilings` (type: `integer`):

How many of the company's most recent 13D/13G filings to classify and rank.

## `minImpact` (type: `integer`):

Only return filings at or above this impact score (e.g. 70 = high-impact: new/active activist 13D stakes). 0 = all.

## `onlyInbound` (type: `boolean`):

If on, return only stakes taken IN the company (inbound), hiding filings where the company itself takes a stake in another (outbound).

## Actor input object example

```json
{
  "tickers": [
    "GME",
    "AAPL"
  ],
  "maxFilings": 25,
  "minImpact": 0,
  "onlyInbound": false
}
```

# 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": [
        "GME",
        "AAPL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datasignalslab/sec-13dg-activist-stake-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 = { "tickers": [
        "GME",
        "AAPL",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datasignalslab/sec-13dg-activist-stake-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "GME",
    "AAPL"
  ]
}' |
apify call datasignalslab/sec-13dg-activist-stake-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datasignalslab/sec-13dg-activist-stake-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC 13D/G Activist Stake Monitor - Stakes & Intent Signals",
        "description": "SEC 13D/13G activist stake monitor: who takes a 5%+ stake, activist vs passive, with filer and impact score. Pay per company.",
        "version": "0.1",
        "x-build-id": "BZ8J5Z4gkwdy4HAmm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datasignalslab~sec-13dg-activist-stake-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datasignalslab-sec-13dg-activist-stake-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datasignalslab~sec-13dg-activist-stake-monitor/runs": {
            "post": {
                "operationId": "runs-sync-datasignalslab-sec-13dg-activist-stake-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datasignalslab~sec-13dg-activist-stake-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-datasignalslab-sec-13dg-activist-stake-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "tickers"
                ],
                "properties": {
                    "tickers": {
                        "title": "Tickers or CIKs",
                        "type": "array",
                        "description": "One or more US stock tickers (e.g. GME, AAPL, TSLA) or 10-digit SEC CIK numbers. Each is scanned for recent Schedule 13D/13G stake filings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxFilings": {
                        "title": "Max filings per company",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "How many of the company's most recent 13D/13G filings to classify and rank.",
                        "default": 25
                    },
                    "minImpact": {
                        "title": "Minimum impact score (0-100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return filings at or above this impact score (e.g. 70 = high-impact: new/active activist 13D stakes). 0 = all.",
                        "default": 0
                    },
                    "onlyInbound": {
                        "title": "Only inbound stakes",
                        "type": "boolean",
                        "description": "If on, return only stakes taken IN the company (inbound), hiding filings where the company itself takes a stake in another (outbound).",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
