# Institutional Ownership by Ticker - Who Owns a Stock (SEC 13F) (`smartmoney-data/institutional-ownership-by-ticker`) Actor

Every hedge fund and institution holding a US stock, from official SEC 13F data: shares, value, % of institutional holdings and quarter-over-quarter changes (new, added, reduced, exited positions). Plus a per-stock summary with top buyers and sellers.

- **URL**: https://apify.com/smartmoney-data/institutional-ownership-by-ticker.md
- **Developed by:** [SmartMoney Data](https://apify.com/smartmoney-data) (community)
- **Categories:** Business, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 holder 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/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

## Institutional Ownership by Ticker - Who Owns a Stock (SEC 13F)

**Type a ticker, get every hedge fund and institution that owns it, how many shares they hold, and who bought or sold last quarter.**

| | |
|---|---|
| **Data** | Official SEC Form 13F data sets: every 13F filer with $100M+ under management |
| **Price** | $2 per 1,000 holder rows, no subscription. Apify's free plan credit covers a first test. |
| **Freshness** | Quarterly; the SEC publishes a new data set every three months, about 45 to 90 days after the quarter ends |
| **Try it** | The input is pre-filled with a working example: just click **Start**. |

**Example output**

| Fund | Action | Shares | Value | Change | % of 13F shares |
|---|---|---|---|---|---|
| Example Index Advisors | ADDED | 1,412,000,000 | $289.4B | +1.8% | 9.4 |
| Example Capital LP | REDUCED | 300,000,000 | $61.5B | -25.0% | 2.0 |
| Newcomer Partners | NEW | 2,100,000 | $0.4B | | 0.01 |

*Illustrative rows; real runs return the full fields listed under Output.*

Most "who owns this stock" pages show you the top 10 holders, a quarter late, behind a paywall. This Actor reads the SEC's own quarterly Form 13F data sets (every 13F filer, every position) and returns the full list of institutional holders for any US stock, with a clear label for each one: **NEW**, **ADDED**, **REDUCED**, **UNCHANGED** or **EXITED** versus the previous quarter.

### What you can do with it

- 🏦 **Full holder list:** every fund that filed a 13F position in the stock, not just the top 10.
- 📈 **Who is buying, who is selling:** quarter-over-quarter share changes and the top buyers and sellers per stock.
- 🆕 **Spot new money:** funds that opened a position this quarter.
- 🚪 **See who left:** funds that sold their entire stake.
- 🔗 **Pair with fund-level data:** follow a single fund's whole portfolio with [Hedge Fund 13F Tracker](https://apify.com/smartmoney-data/sec-13f-hedge-fund-tracker).

### How to use it

#### Holders of a few stocks, with quarter-over-quarter changes

```json
{ "tickers": ["AAPL", "NVDA", "TSLA"] }
```

#### Top 20 holders only, current quarter

```json
{ "tickers": ["PLTR"], "maxHoldersPerTicker": 20, "compareWithPreviousQuarter": false }
```

#### A specific share class

```json
{ "tickers": ["GOOG"], "cusips": ["GOOG=02079K107"] }
```

### Output

For each ticker you get one `ticker-summary` row, then one `holder` row per institution, largest first:

```json
{
  "type": "holder",
  "ticker": "AAPL",
  "cusip": "037833100",
  "reportPeriod": "2026-06-30",
  "previousPeriod": "2026-03-31",
  "filer": "Example Capital LP",
  "filerCik": "0001234567",
  "action": "REDUCED",
  "shares": 300000000,
  "valueUsd": 61500000000,
  "previousShares": 400000000,
  "changeShares": -100000000,
  "changePct": -25,
  "pctOfInstitutionalShares": 2.0,
  "putShares": 0,
  "callShares": 0,
  "filedOn": "2026-08-14",
  "filingUrl": "https://www.sec.gov/Archives/edgar/data/1234567/000123456726000001/"
}
```

```json
{
  "type": "ticker-summary",
  "ticker": "AAPL",
  "companyName": "Apple Inc.",
  "reportPeriod": "2026-06-30",
  "holders": 5120,
  "totalShares": 9450000000,
  "totalValueUsd": 1937000000000,
  "netShareChange": -42000000,
  "newPositions": 210,
  "added": 2300,
  "reduced": 1980,
  "exited": 160,
  "topBuyers": [{ "filer": "Example Index Advisors", "changeShares": 25000000, "action": "ADDED" }],
  "topSellers": [{ "filer": "Example Capital LP", "changeShares": -100000000, "action": "REDUCED" }]
}
```

Options (puts and calls) are reported separately in `putShares` and `callShares` and are not counted in `shares`. Amended 13F filings are applied: restatements replace the original report, "new holdings" amendments add to it.

### Use it from code or an AI agent

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("smartmoney-data/institutional-ownership-by-ticker").call(run_input={"tickers": ["AAPL", "NVDA"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**AI agents (Claude, ChatGPT, Cursor and other MCP clients):** connect the Apify MCP server with this Actor preloaded:

```text
https://mcp.apify.com/?tools=smartmoney-data/institutional-ownership-by-ticker
```

Add this URL as a remote MCP server or custom connector in your AI client, sign in with Apify (OAuth), then just ask, for example:

> Which hedge funds opened new positions in NVDA last quarter?

> Part of the **SmartMoney Data** suite: [Hedge Fund 13F](https://apify.com/smartmoney-data/sec-13f-hedge-fund-tracker) · [13F Consensus](https://apify.com/smartmoney-data/hedge-fund-13f-consensus) · [Insider Trades](https://apify.com/smartmoney-data/sec-insider-trades-tracker) · [Dark Pool Volume](https://apify.com/smartmoney-data/dark-pool-volume-tracker) · [Smart Money Confluence](https://apify.com/smartmoney-data/smart-money-confluence-score)

### Pricing

**Pay per result:** you're charged for each row returned (holders and the per-stock summary). See the **Pricing** tab for current rates.

### FAQ

**Who has to file a 13F?**
Any institutional investment manager with $100 million or more in US-listed equities: hedge funds, mutual fund companies, banks, pensions and family offices.

**Why is the data a quarter behind?**
Managers have 45 days after each quarter to file, and the SEC publishes the bulk data set after that. It is the same data every 13F site uses, straight from the source.

**Are short positions included?**
No. 13F filings only cover long positions (plus put and call options, shown separately).

**Is this legal to use?**
Yes. Form 13F filings are public records published by the SEC.

### Support

Found a bug or need a feature? Open an issue on the **Issues** tab or email **smartmoney-data@googlegroups.com**.

*Data is provided for informational purposes only and is not investment advice.*

# Actor input Schema

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

US stock tickers to look up, e.g. AAPL, NVDA, TSLA.

## `maxHoldersPerTicker` (type: `integer`):

Largest holders returned per stock, by shares held. Exited positions are capped separately.

## `compareWithPreviousQuarter` (type: `boolean`):

Label each holder NEW, ADDED, REDUCED or UNCHANGED versus the quarter before, and list funds that exited.

## `includeExited` (type: `boolean`):

Also return funds that held the stock last quarter but sold all of it.

## `cusips` (type: `array`):

Optional TICKER=CUSIP pairs (e.g. GOOG=02079K107) when you want a specific share class. Normally the CUSIP is found automatically.

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

The SEC asks automated clients to identify themselves with a name and email. The default works.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "NVDA"
  ],
  "maxHoldersPerTicker": 100,
  "compareWithPreviousQuarter": true,
  "includeExited": true
}
```

# Actor output Schema

## `holders` (type: `string`):

No description

## `summary` (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",
        "NVDA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("smartmoney-data/institutional-ownership-by-ticker").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",
        "NVDA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("smartmoney-data/institutional-ownership-by-ticker").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",
    "NVDA"
  ]
}' |
apify call smartmoney-data/institutional-ownership-by-ticker --silent --output-dataset

```

## MCP server setup

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

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/wAmQTHOpYIepESe3g/builds/PYTFHHND094KulPFQ/openapi.json