# SEC 13F Holdings & Changes Feed (institutional portfolios) (`moment-data/sec-13f-holdings-changes-feed`) Actor

Daily feed of new SEC Form 13F-HR filings by hedge funds and institutional managers: total value, positions, top holdings, and quarter-over-quarter new/increased/decreased/exited positions. Filter by manager, CUSIP, issuer, size.

- **URL**: https://apify.com/moment-data/sec-13f-holdings-changes-feed.md
- **Developed by:** [Luke Miller](https://apify.com/moment-data) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## SEC 13F Holdings & Changes Feed: Institutional Portfolios, Parsed

Every institutional investment manager with $100M+ in US equities (hedge funds, asset managers, banks, pensions, endowments, family offices) must file a **Form 13F-HR** with the SEC each quarter. This Actor turns those filings into a clean daily feed: **who filed, total portfolio value, number of positions, top holdings, and (optionally) what they bought, added to, trimmed and sold since last quarter**, straight from official SEC EDGAR data.

### Who uses it

- **Investors and analysts:** follow "smart money": see new positions and full exits by hedge funds and large managers the day the 13F is filed.
- **Investor-relations teams:** find out which institutions opened, increased or exited a position in your stock (filter by your CUSIP).
- **Fintech and data teams:** feed parsed, normalized 13F data into dashboards, screeners and alerting without maintaining an EDGAR parser.
- **Sales and business development (fund services, prime brokers, software vendors):** a fresh list of active institutional managers with portfolio size, location and filing details.
- **Journalists and researchers:** track ownership concentration and manager behaviour quarter by quarter.

### What you get

- **Filing summary (default):** manager name, CIK, period of report, filing date, new vs amendment (with amendment type), report type, manager city and state/country, 13F file number, CRD and SEC file numbers, **total portfolio value (USD)**, number of positions, put/call positions, top-10 concentration and the **top 10 holdings** with % of portfolio.
- **Per-holding records (`holdings` mode):** issuer, CUSIP, class, FIGI, value (USD), shares or principal amount, SH/PRN, put/call, investment discretion, voting authority (sole/shared/none), % of portfolio and rank.
- **Quarter-over-quarter changes (`compareWithPrevious`):** the Actor fetches the manager's previous 13F holdings report and classifies every position as **new, increased, decreased, exited or unchanged** (by share / principal amount), with previous shares and value, share change and % change. Filing summaries get counts plus the top new, increased, decreased and exited positions.
- **Filters applied before you pay:** manager CIKs, manager name, minimum portfolio value, issuer CUSIP (9-character or 6-character issuer prefix), issuer name, include/exclude amendments, change types.
- **Entity-only:** signature-block names, titles and phone numbers and street addresses are never output. Filers that are clearly individual people are skipped.
- **Only new since last run** (opt-in) for daily schedules: pay only for filings you have not received before.

### Quick start

1. Run with the defaults (`{}`) to get 25 13F filing summaries from the latest EDGAR business day in about 10 seconds. If that day had few 13Fs (mid-quarter), the Actor automatically reads older business days.
2. Track specific managers' latest moves, for example Berkshire Hathaway, one record per changed position:

```json
{
  "mode": "holdings",
  "filerCiks": ["1067983"],
  "compareWithPrevious": true,
  "changeTypes": ["new", "increased", "decreased", "exited"],
  "maxItems": 200
}
```

3. Who holds your stock? Large managers that filed a position in Apple (CUSIP prefix 037833):

```json
{ "issuerCusips": ["037833"], "minPortfolioValue": 1000000000, "compareWithPrevious": true, "maxItems": 100 }
```

4. **Schedule tip:** create an Apify Schedule that runs every weekday morning (for example 7:00 America/New_York, after EDGAR publishes the previous day's index at about 10 pm ET) with `"sinceLastRun": true`, a unique `"stateKey"` and a higher `maxItems`. Each run then delivers only filings you have not seen. Connect a webhook, Google Sheets, Slack or Zapier/Make integration to get alerts where you work.

### Input

| Field | Meaning |
|---|---|
| `mode` | `filings` (default, one summary per filing) or `holdings` (one record per position / change) |
| `compareWithPrevious` | Compare with the manager's previous 13F, default false |
| `changeTypes` | Holdings mode + compare: `new`, `increased`, `decreased`, `exited`, `unchanged` (default: all but unchanged) |
| `filerCiks` | Manager CIKs; returns each manager's latest 13F-HR filed in the last 150 days |
| `filerNameContains` | Manager name words |
| `minPortfolioValue` | Minimum reported 13F portfolio value (USD) |
| `issuerCusips` | 9-character CUSIPs or 6-character issuer prefixes |
| `issuerNameContains` | Issuer name words, e.g. `NVIDIA` |
| `includeAmendments` | Include 13F-HR/A amendments, default true |
| `sinceLastRun` | Opt-in: only filings not delivered before for this `stateKey` (**use for schedules**) |
| `daysBack` | Minimum latest EDGAR business days to read, default 1 |
| `autoWiden` / `maxLookbackDays` | Keep reading older business days until `maxItems` is reached, up to 10 business days by default |
| `maxItems` | Cap per run (also caps your spend), default 25 |
| `maxHoldingsPerFiling` | Holdings mode: only the largest N positions (or changes) per filing, 0 = all |
| `maxFilingsToCheck` | Safety cap on filings inspected with narrow filters, default 150 |
| `contactEmail` | Optional; added to the User-Agent sent to the SEC |
| `stateKey` | One key per saved schedule (sinceLastRun) |

### Output (examples, real records)

Filing summary (`filings` mode with `compareWithPrevious`, filed Oct 30, 2026):

```json
{
  "managerName": "3Chopt Investment Partners, LLC",
  "cik": 1978521,
  "formType": "13F-HR",
  "filingType": "new",
  "periodOfReport": "2026-09-30",
  "filingDate": "2026-10-30",
  "reportType": "13F HOLDINGS REPORT",
  "managerCity": "RICHMOND",
  "managerStateOrCountry": "VA",
  "totalValue": 557795951,
  "positionCount": 294,
  "top10ConcentrationPct": 42.05,
  "topHoldings": [
    { "issuer": "VANGUARD INDEX FDS", "cusip": "922908363", "titleOfClass": "S&P 500 ETF SHS", "value": 65574018, "shares": 93562, "pctOfPortfolio": 11.76 },
    { "issuer": "NVIDIA CORPORATION", "cusip": "67066G104", "titleOfClass": "COM", "value": 38977995, "shares": 170495, "pctOfPortfolio": 6.99 }
  ],
  "comparison": {
    "previousPeriod": "2026-06-30",
    "previousTotalValue": 532096866,
    "totalValueChangePct": 4.83,
    "newPositions": 39, "increasedPositions": 156, "decreasedPositions": 70, "exitedPositions": 19, "unchangedPositions": 29,
    "topNew": [{ "issuer": "EXXONMOBIL HOLDINGS CORP", "cusip": "30233Q108", "value": 3863825, "shares": 23741 }],
    "topExited": [{ "issuer": "VANGUARD WORLD FD", "cusip": "921910873", "previousValue": 1840162, "previousShares": 6725 }]
  },
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1978521/000139834426019153/0001398344-26-019153-index.htm"
}
```

Holding change (`holdings` mode, Berkshire Hathaway, Q2 2026 vs Q1 2026):

```json
{
  "managerName": "Berkshire Hathaway Inc",
  "cik": 1067983,
  "periodOfReport": "2026-06-30",
  "filingDate": "2026-08-14",
  "issuer": "ALPHABET INC",
  "cusip": "02079K305",
  "titleOfClass": "CAP STK CL A",
  "value": 28157599351,
  "shares": 78791167,
  "sharesOrPrincipalType": "SH",
  "putCall": null,
  "investmentDiscretion": "DFND",
  "pctOfPortfolio": 9.409,
  "rankInPortfolio": 4,
  "changeType": "increased",
  "previousPeriod": "2026-03-31",
  "previousShares": 54249798,
  "sharesChange": 24541369,
  "sharesChangePct": 45.24,
  "valueChange": 12557527438
}
```

(Fields shortened; see `sample-output.json` for full records.) Every run also writes a summary (business days read, filings inspected, filtered, delivered, SEC requests) to the `OUTPUT` record.

### Timing you should know about

- 13F-HR is due **45 days after each quarter end** (around Feb 14, May 15, Aug 14 and Nov 14). Most filings arrive in the last two weeks before the deadline (200+ per day); mid-quarter only late filers and amendments appear, so the default run widens its window automatically.
- EDGAR publishes the daily form index **nightly** (about 10 pm ET). A run picks up everything filed through the previous business day; weekends and federal holidays are skipped automatically.

### FAQ

**How are positions matched across quarters?** By CUSIP + put/call + share/principal type. Rows the manager splits by investment discretion or other manager are merged into one position (discretions are listed). Change type is driven by shares (or principal amount), because value also moves with price.

**What if a company changed its CUSIP (merger, reorganization)?** It shows as one exited and one new position, exactly as reported.

**Are values in dollars?** Yes. Filings made since January 3, 2023 report values in dollars; older filings (in $ thousands) are converted. A few managers still report in thousands by mistake; filing summaries carry a `valueUnitsNote` when the total looks implausibly small.

**Which previous filing is used?** The manager's latest original 13F-HR for the most recent earlier period (amendments that only add holdings are not merged). The record shows `previousPeriod` and `previousAccessionNumber` so you can verify.

**What about 13F-NT (notice) filings?** They contain no holdings (another manager reports them), so they are skipped.

**Does it include personal data?** No. Signer names, titles, phone numbers and street addresses are never output, and filers that are clearly individuals are skipped.

### Data source and fair access

- Sources: the SEC EDGAR daily form index (`sec.gov/Archives/edgar/daily-index`), each filing's submission text (13F cover page + information table XML) and `data.sec.gov` submissions JSON (to find the previous quarter's filing). The SEC states that EDGAR public filing content is free to access and reuse ([SEC FAQ](https://www.sec.gov/about/webmaster-frequently-asked-questions)).
- The Actor follows the SEC's [fair access rules](https://www.sec.gov/search-filings/edgar-search-assistance/accessing-edgar-data): a declared User-Agent, at most 4 requests per second (limit is 10), and backoff on errors.
- Not affiliated with or endorsed by the SEC. 13F data is self-reported by managers, delayed by up to 45 days and provided as filed; it is not investment advice.

### Pricing

Pay per event (Apify takes care of billing; you only pay for what is delivered):

| Event | Price | Charged |
|---|---|---|
| `apify-actor-start` | $0.005 | once per run |
| `filing-record` | $0.004 | per 13F filing summary delivered (`filings` mode) |
| `holding-record` | $0.002 | per holding or position change delivered (`holdings` mode) |

A default test run (25 filing summaries) costs about $0.105. Following 10 managers' changes each quarter in holdings mode (~40 changed positions each) costs about $0.81 per quarter. Filings and holdings removed by your filters are free. `maxItems` and Apify's *max cost per run* cap your spend; the Actor stops delivering when your budget is reached, so you are never charged for more than you set. No separate platform-usage charges: compute is included in the event prices.

# Actor input Schema

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

filings (default): one summary record per 13F filing (manager, period, total value, position count, top 10 holdings, optional quarter-over-quarter change summary). holdings: one record per position.

## `compareWithPrevious` (type: `boolean`):

Fetch each manager's previous 13F holdings report and classify positions as new, increased, decreased, exited or unchanged (by share / principal amount). Filings mode adds counts and top changes; holdings mode emits one record per change, including exited positions.

## `changeTypes` (type: `array`):

Which position changes to deliver in holdings mode when comparing: new, increased, decreased, exited, unchanged.

## `filerCiks` (type: `array`):

SEC CIK numbers of institutional managers to follow, e.g. 1067983 (Berkshire Hathaway), 1350694 (Bridgewater). Returns each manager's latest 13F-HR filed in the last 150 days (sinceLastRun: every new one). Leave empty to read the daily feed of all managers.

## `filerNameContains` (type: `array`):

Keep filings whose manager name contains any of these words (case-insensitive), e.g. capital, partners, bank.

## `minPortfolioValue` (type: `integer`):

Keep only managers whose reported 13F portfolio value is at least this much, e.g. 1000000000 for $1B+.

## `issuerCusips` (type: `array`):

Keep holdings (and filings holding) any of these CUSIPs. A 6-character issuer prefix matches all of the issuer's securities, e.g. 037833 for Apple.

## `issuerNameContains` (type: `array`):

Keep holdings (and filings holding) issuers whose name contains any of these words, e.g. NVIDIA, TESLA.

## `includeAmendments` (type: `boolean`):

Also deliver 13F-HR/A amendments (restatements and added holdings).

## `sinceLastRun` (type: `boolean`):

Opt-in: remember delivered filings under the State key and only deliver filings not seen before. Use for daily schedules. Off by default (stateless).

## `daysBack` (type: `integer`):

Minimum number of the latest EDGAR business days to read (weekends and holidays skipped).

## `autoWiden` (type: `boolean`):

If fewer than Max items match, keep reading older business days (up to Max lookback days). Useful mid-quarter, when few 13Fs are filed.

## `maxLookbackDays` (type: `integer`):

Upper limit for the widened window.

## `maxItems` (type: `integer`):

Hard cap on delivered records (filings or holdings, also caps your spend). Default is small for a quick, cheap first run.

## `maxHoldingsPerFiling` (type: `integer`):

Holdings mode: deliver only the largest N positions (or changes) of each filing. 0 = all.

## `maxFilingsToCheck` (type: `integer`):

Safety cap on how many 13F filings are downloaded per run when narrow filters are used. You are only charged for delivered records.

## `contactEmail` (type: `string`):

SEC asks automated clients to declare a contact in the User-Agent. Optional: if set, it is added to the User-Agent sent to sec.gov.

## `stateKey` (type: `string`):

Name of the saved history for sinceLastRun. Use one key per schedule.

## Actor input object example

```json
{
  "mode": "filings",
  "compareWithPrevious": false,
  "changeTypes": [
    "new",
    "increased",
    "decreased",
    "exited"
  ],
  "minPortfolioValue": 0,
  "includeAmendments": true,
  "sinceLastRun": false,
  "daysBack": 1,
  "autoWiden": true,
  "maxLookbackDays": 10,
  "maxItems": 25,
  "maxHoldingsPerFiling": 0,
  "maxFilingsToCheck": 150,
  "stateKey": "default"
}
```

# Actor output Schema

## `filings` (type: `string`):

One record per 13F filing (filings mode).

## `holdings` (type: `string`):

One record per position or position change (holdings mode).

## `summary` (type: `string`):

Business days read, counts, filters.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("moment-data/sec-13f-holdings-changes-feed").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("moment-data/sec-13f-holdings-changes-feed").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 '{}' |
apify call moment-data/sec-13f-holdings-changes-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moment-data/sec-13f-holdings-changes-feed"
        }
    }
}
```

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/3OoCgC94HbM1u0XLZ/builds/48g6nNMqFjY6BtC59/openapi.json