# Institutional Ownership Tracker: Who Owns a Stock (`scrapemint/institutional-ownership-tracker`) Actor

Keyless institutional ownership data for any US stock from NASDAQ: what percent is held by institutions, how many holders increased versus decreased their positions, new and sold-out positions, and every institution's shares held, share change and position value. Pay per row.

- **URL**: https://apify.com/scrapemint/institutional-ownership-tracker.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 ownership 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/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

## Institutional Ownership Tracker: Who Owns a Stock

Keyless **institutional ownership** data for any US stock, from **NASDAQ**. No API key, no account, no terminal subscription. Answers the question every investor asks about a position: is smart money accumulating this, or getting out?

- **Summary** — one row per ticker: what percent of the float institutions hold, how many holders **increased** versus **decreased**, how many opened **new** positions versus **sold out** entirely, and the accumulation ratio those imply.
- **Holders** — one row per institution, with shares held, share change, percent change and position value. Large caps have thousands of holders, sorted by position value, share change or shares held.
- **Movers** — only the institutions that actually moved, biggest buyers and biggest sellers side by side, instead of thousands of unchanged rows.

### Who uses it

- **Investors and traders** — institutional accumulation is a positioning signal, and a stock quietly being sold by its largest holders is worth knowing before you buy it.
- **Investor relations and corporate finance teams** — see your own register: who holds you, who is adding, who left.
- **Analysts and newsletters** — "institutions added nine shares for every one they sold last quarter" is a story, and it comes straight off the summary row.
- **Fund and competitor research** — find every institution with a position in a name you care about.

Points the opposite way to our [SEC 13F Whale Tracker](https://apify.com/scrapemint/sec-13f-whale-tracker), which starts from a filer and lists what they own. This starts from a stock and lists who owns it. Pairs with [Stock Analyst Ratings](https://apify.com/scrapemint/stock-analyst-ratings) and [Stock Market Movers](https://apify.com/scrapemint/stock-market-movers).

### Input

| Field | Description |
|-------|-------------|
| `mode` | `summary`, `holders`, or `movers`. |
| `symbols` | US tickers, e.g. `NVDA`, `TSLA`, `AAPL`. Max 100 per run. |
| `holdersPerSymbol` | How many institutions per ticker in holders mode. The main cost lever. |
| `moversPerSide` | How many biggest buyers and biggest sellers per ticker. |
| `sortBy` | `marketValue` / `sharesChange` / `sharesHeld`. |
| `minSharesChange` | Skip institutions whose position barely moved. |
| `maxRows` | Row cap per run. |

### Output

- **Summary**: `symbol`, `institutionalOwnershipPercent`, `sharesOutstandingMillions`, `totalHoldingsValueUsd`, `totalInstitutionalHolders`, `totalSharesHeld`, `increasedHolders`, `increasedShares`, `decreasedHolders`, `decreasedShares`, `unchangedHolders`, `newPositionHolders`, `newPositionShares`, `soldOutHolders`, `soldOutShares`, `netSharesChange`, `accumulationRatio`, `holderAccumulationRatio`.
- **Holders and movers**: `symbol`, `ownerName`, `reportDate`, `sharesHeld`, `sharesChange`, `sharesChangePercent`, `positionValueUsd`, `direction`.

`accumulationRatio` is shares bought divided by shares sold across all holders. Above 1 means institutions added more than they trimmed. `holderAccumulationRatio` is the same idea counted in institutions rather than shares, which is a better read on breadth: a single large buyer can carry the share ratio on its own.

### Notes on the data

- This is **13F data**, so it is quarterly and it lags. Institutions file within 45 days of quarter end, and each holder files on its own schedule, which is why `reportDate` differs from row to row within one stock. That is the filing calendar, not a gap in the scrape.
- Position value is published in thousands and is converted to whole dollars here, so `positionValueUsd` is directly comparable across rows.
- 13F covers long US equity positions only. It does not show shorts, options overlays or non-US holdings, so a holder's real exposure can differ from what is filed.
- A ticker with no published ownership data returns a free note row rather than an error.

### Pricing

Pay per event: **$0.005 per row**. The first 2 rows of every run are free.

Data source: NASDAQ institutional holdings (`api.nasdaq.com`).

# Actor input Schema

## `mode` (type: `string`):

summary = one row per ticker with ownership percent, holders increased vs decreased, and the accumulation ratio. holders = one row per institution holding the stock. movers = only the institutions that actually changed their position, biggest buyers and biggest sellers.

## `symbols` (type: `array`):

US tickers to look up, e.g. NVDA, TSLA, AAPL. Maximum 100 per run.

## `holdersPerSymbol` (type: `integer`):

How many institutions to return for each ticker, taken from the top of the sort. Large caps have thousands of holders, so this is the main cost lever.

## `moversPerSide` (type: `integer`):

How many biggest buyers and how many biggest sellers to return per ticker. 10 returns up to 20 rows per ticker.

## `sortBy` (type: `string`):

Order institutions by position value, share change, or shares held.

## `minSharesChange` (type: `integer`):

Skip institutions whose position moved by fewer shares than this, in either direction. 0 = keep every holder.

## `maxRows` (type: `integer`):

Cap on rows returned across all tickers. Controls total cost.

## Actor input object example

```json
{
  "mode": "summary",
  "symbols": [
    "NVDA",
    "TSLA",
    "AAPL",
    "MSFT",
    "AMZN",
    "GOOGL"
  ],
  "holdersPerSymbol": 25,
  "moversPerSide": 10,
  "sortBy": "marketValue",
  "minSharesChange": 0,
  "maxRows": 200
}
```

# 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 = {
    "symbols": [
        "NVDA",
        "TSLA",
        "AAPL",
        "MSFT",
        "AMZN",
        "GOOGL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/institutional-ownership-tracker").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 = { "symbols": [
        "NVDA",
        "TSLA",
        "AAPL",
        "MSFT",
        "AMZN",
        "GOOGL",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/institutional-ownership-tracker").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 '{
  "symbols": [
    "NVDA",
    "TSLA",
    "AAPL",
    "MSFT",
    "AMZN",
    "GOOGL"
  ]
}' |
apify call scrapemint/institutional-ownership-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapemint/institutional-ownership-tracker"
        }
    }
}

```

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/IadrwHDkcbHAMbKst/builds/jCCtuqvLfC1wUb2no/openapi.json