# SEC 13F Institutional Holdings by Fund or Stock from EDGAR (`yadroo/sec-13f-fund-holdings`) Actor

Quarterly positions from SEC Form 13F-HR filings, one row per holding: issuer, CUSIP, share class, shares, value in USD, share of the manager's portfolio, put/call, voting authority and discretion. Ask by manager name or CIK, or by stock to get every filer holding it. UTC dates.

- **URL**: https://apify.com/yadroo/sec-13f-fund-holdings.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** Business, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 holding rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Institutional Holdings by Fund or Stock from EDGAR

Quarterly positions from SEC Form 13F-HR filings, one row per holding: issuer, CUSIP, share class, shares, value in USD, share of the manager's portfolio, put/call, voting authority and discretion. Ask by manager name or CIK, or by stock to get every filer holding it. UTC dates.

Every institutional manager with at least $100 million in US-listed equity authority files a Form 13F-HR each quarter, and the positions sit in an XML information table inside the filing. This actor reads those tables straight from SEC EDGAR and turns them into rows you can sort, filter and export: a manager's portfolio by name or CIK, or the holder list of one security by CUSIP or issuer name. No API key, no account, no proxy and no browser — the data is public domain.

> **Need it tailored to your workflow?** Missing a field, a filter, another source or a different output format? [Open an issue](https://apify.com/yadroo/sec-13f-fund-holdings/issues) and describe what you need — we read every request and adapt the actor.

### Use cases

- **Follow one manager's portfolio**: give `funds` a name or CIK and get the positions reported for the quarter, largest first, with each position's share of the reported portfolio.
- **Find every institutional holder of a stock**: `mode: issuer` with a CUSIP (or an issuer name) returns the managers that reported it, with share counts and dollar values — the ownership side of the same filings.
- **Read a quarter against the one before**: `comparePreviousQuarter` adds share and value changes and labels each position new, increased, reduced, unchanged or sold, so buys, trims and exits are visible in one run.
- **Check a watchlist**: several managers in `funds` plus CUSIPs or issuer names in `issuerFilter` answers "does any of these funds still hold this?" in one run, one row per position found.
- **Top of a very large book**: a manager that reports thousands of lines, cut to what matters with `minValueUsd` and `maxItems` before you pay for rows.
- **Build a historical panel**: one quarter per run from 2013 Q2 onwards, with `fields` picking the columns your spreadsheet or database load expects.
- **Watch the deadline days**: on the three days around the 45-day deadline, `sinceHours` plus `onlyNew` on a schedule delivers only filings that arrived since the last run.

### Input

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `mode` | string | `fund` | Strict dropdown: `fund` (positions of the managers you name) or `issuer` (managers holding one security). An off-list value is refused by the platform before the run starts. |
| `funds` | string\[] | – | `fund` mode. Manager names as EDGAR spells them (`Berkshire Hathaway Inc`) or CIK numbers (`0001067983`, `1067983` — zeros are added for you). Free text: see [Manager names](#manager-names). At most 25 per run. |
| `issuer` | string | – | `issuer` mode. A 9-character CUSIP (`037833100` = Apple common stock) matches exactly; an issuer name (`NVIDIA CORP`) is matched as a phrase against the filed `nameOfIssuer`, where spellings differ between managers and a short or common word also pulls in unrelated securities — so a CUSIP is the precise way to ask. A ticker is refused with the reason: 13F tables have no ticker column. |
| `quarter` | string | `latest` (empty = `latest`) | `latest`, `2026Q2`, `2026-Q2`, `Q2 2026`, `2026-06-30` or `06-30-2026`. `latest` = the newest quarter whose 45-day deadline has passed. Quarters before 2013Q2 are refused. |
| `issuerFilter` | string\[] | – (all) | `fund` mode: keep only these securities. A 9-character CUSIP matches exactly; anything else matches when the filed issuer name contains it, case-insensitively. |
| `minValueUsd` | number | `0` | Drop positions reported below this dollar value, after values filed in thousands are converted. |
| `sortBy` | string | `valueDesc` | Strict dropdown: `valueDesc` (largest position first) or `asFiled`. Sorting happens inside each filing, which is where `maxItems` cuts. An off-list value is refused by the platform before the run starts. |
| `comparePreviousQuarter` | boolean | `false` | Adds `prevShares`, `prevValueUsd`, `sharesChange`, `sharesChangePct` and `changeType`, and returns exited positions as rows with `shares: 0`. One extra filing per manager. |
| `includeAmendments` | boolean | `true` | Use 13F-HR/A filings. See [Amendments](#amendments). |
| `sinceHours` | integer | – (all) | 1–8760. Skip filings accepted longer ago than this. `fund` mode uses the acceptance timestamp; `issuer` mode only has the filing date, so the window is rounded to whole days there. A manager whose filing for the quarter is older than the window produces no rows at all, and the run status names the filing it skipped. |
| `onlyNew` | boolean | `false` | Skip rows this task delivered in an earlier run. A row is remembered by manager CIK, quarter, accession number, the line's position on the information table and the CUSIP. |
| `fields` | string\[] | – (full row) | Keep only these columns, **in this order**. The always-kept columns you do not list come first: `fundName`, `fundCik`, `quarter`, `periodOfReport`, `filedAt`, `accessionNumber`, `nameOfIssuer`, `cusip`, `shares`, `valueUsd`, `url`, `fetchedAt`. A column you do name stays where you put it. Names are matched loosely (`value`, `value_usd`, `ISSUER`); an unknown name is refused with the closest match. |
| `maxItems` | integer | `50` | 1–5000. Hard cap on dataset rows for the whole run, and on what you pay for. |

Nothing is required: `mode` decides whether `funds` or `issuer` is needed, and the run stops with a message naming the missing field.

### Reference

#### Modes

| Value | What the run does |
|---|---|
| `fund` | Resolves each entry of `funds` to one filer, reads its Form 13F-HR filings for the quarter and returns every line of their information tables. |
| `issuer` | Searches EDGAR full-text search for the CUSIP or issuer name in 13F-HR filings of that quarter and returns the matching lines of each filing, one manager at a time. |

#### Sort orders

| Value | Order of rows |
|---|---|
| `valueDesc` | Largest reported value first, inside each filing. With `maxItems: 25` this gives the 25 largest positions of the filing. |
| `asFiled` | The order the manager filed, which for most filing agents is roughly alphabetical by issuer. |

#### Manager names

`funds` is free text on purpose: manager names are typed loosely and EDGAR has no closed dictionary of them. A name is matched against the filer names EDGAR's own search returns, ignoring case, extra spaces, punctuation and legal suffixes — `bridgewater associates lp` finds `Bridgewater Associates, LP`, and `AQR Capital Management, LLC` finds `AQR CAPITAL MANAGEMENT LLC`, which EDGAR spells without the comma (the comma may sit on either side). Any other spelling is refused with a suggestion instead of being swapped for something near: `bridgewater` alone matches three filers, so the run stops and lists them with their CIKs (`Bridgewater Associates, LP (CIK 0001350694)`, …) and you re-run with the full name or the CIK. A CIK is always exact. When a value was read through another spelling, the run status says so.

#### Columns of an information table

| Value | Meaning |
|---|---|
| `sharesOrPrincipalType` `SH` | The number in `shares` is a share count. |
| `sharesOrPrincipalType` `PRN` | The number in `shares` is a principal amount (debt), not shares. |
| `investmentDiscretion` `SOLE` | The filer alone decides on this position. |
| `investmentDiscretion` `DFND` | Discretion is defined (shared with the included managers named in `otherManager`). |
| `investmentDiscretion` `OTR` | Another manager decides. |
| `putCall` `PUT` / `CALL` | The position is an option on the security, not the security itself; empty for ordinary holdings. |
| `reportType` | `13F HOLDINGS REPORT` (holdings), `13F NOTICE` (holdings reported on another manager's filing — skipped, there is no table) or `13F COMBINATION REPORT`. |

#### Amendments

A manager can correct a quarter after the fact with a 13F-HR/A. With `includeAmendments: true` (the default):

- a **restatement** amendment replaces the original table of that quarter, so only the newest restatement is read, and the filing it replaced is named in the run status;
- an amendment that only **adds holdings** is read next to the original;
- an amendment without a stated type counts as a restatement, the reading that never doubles rows.

Every row names its `accessionNumber`, `formType`, `isAmendment` and `amendmentType`, so a number can always be traced to one filing. With `includeAmendments: false` only original 13F-HR filings are read.

#### Change labels

| `changeType` | When |
|---|---|
| `new` | The manager did not report this security last quarter. |
| `increased` / `reduced` | The share total for the security grew or shrank. |
| `unchanged` | Same share total as last quarter. |
| `sold` | Reported last quarter, not reported now: an extra row with `shares: 0` and the previous figures. |

The comparison is per security — all lines of the same CUSIP, share class and put/call added up — because one manager often reports one security on several lines.

#### Quarters and the deadline

Quarter ends are 31 March, 30 June, 30 September and 31 December; a report is due 45 days later (14 February, 15 May, 14 August, 14 November). `latest` therefore means the quarter before the one that just ended: on 10 October 2026 it is 2026Q2, period 2026-06-30.

### Examples

**What one famous manager holds, largest position first**

```json
{ "mode": "fund", "funds": ["Berkshire Hathaway Inc"], "quarter": "latest", "sortBy": "valueDesc", "maxItems": 25 }
```

**Every institutional holder of Apple common stock**

```json
{ "mode": "issuer", "issuer": "037833100", "quarter": "latest", "maxItems": 20 }
```

**Holders of a security you only have a name for**

```json
{ "mode": "issuer", "issuer": "NVIDIA CORP", "quarter": "latest", "maxItems": 20 }
```

**One hedge fund's buys, trims and exits against the previous quarter**

```json
{ "mode": "fund", "funds": ["0001350694"], "quarter": "latest", "comparePreviousQuarter": true, "sortBy": "valueDesc", "maxItems": 25 }
```

**The top of a 4,000-line book, above a dollar floor**

```json
{ "mode": "fund", "funds": ["0000093751"], "quarter": "latest", "minValueUsd": 50000000, "sortBy": "valueDesc", "maxItems": 30 }
```

**Do these funds hold these securities?**

```json
{ "mode": "fund", "funds": ["Berkshire Hathaway Inc", "0001037389"], "quarter": "latest", "issuerFilter": ["037833100", "NVIDIA CORP"], "maxItems": 10 }
```

**One past quarter, only the columns a spreadsheet needs**

```json
{ "mode": "fund", "funds": ["0001037389"], "quarter": "2024Q4", "fields": ["nameOfIssuer", "cusip", "shares", "valueUsd", "pctOfPortfolio"], "maxItems": 25 }
```

### Output

One row per line of an information table. A real row from the cloud run of the first example (run `iPuJetf0b7b9viKFB`, 2026-10-10):

```json
{
  "fundName": "Berkshire Hathaway Inc",
  "fundCik": "0001067983",
  "fundFileNumber": "028-04545",
  "sourceMode": "fund",
  "quarter": "2026Q2",
  "periodOfReport": "2026-06-30",
  "filedAt": "2026-08-14",
  "acceptedAt": "2026-08-15T00:05:04.000Z",
  "accessionNumber": "0001193125-26-352200",
  "formType": "13F-HR",
  "isAmendment": false,
  "amendmentType": null,
  "reportType": "13F HOLDINGS REPORT",
  "nameOfIssuer": "AMERICAN EXPRESS CO",
  "titleOfClass": "COM",
  "cusip": "025816109",
  "putCall": null,
  "shares": 149061045,
  "sharesOrPrincipalType": "SH",
  "valueUsd": 50419898471,
  "valueAsFiled": 50419898471,
  "valueUnitAsFiled": "USD",
  "pctOfPortfolio": 16.8486,
  "investmentDiscretion": "DFND",
  "otherManager": "Buffett Warren E; National Indemnity Co",
  "votingSole": 149061045,
  "votingShared": 0,
  "votingNone": 0,
  "portfolioValueUsd": 299253556246,
  "holdingsReported": 89,
  "otherManagersCount": 14,
  "prevShares": null,
  "prevValueUsd": null,
  "sharesChange": null,
  "sharesChangePct": null,
  "changeType": null,
  "found": true,
  "notFoundReason": null,
  "lineIndex": 13,
  "infoTableUrl": "https://www.sec.gov/Archives/edgar/data/1067983/000119312526352200/56757.xml",
  "url": "https://www.sec.gov/Archives/edgar/data/1067983/000119312526352200/0001193125-26-352200-index.htm",
  "fetchedAt": "2026-10-10T21:04:01.373Z"
}
```

| Field | Type | Meaning |
|---|---|---|
| `fundName` | string | The manager as the cover page spells it. Always filled. |
| `fundCik` | string | Its 10-digit CIK. Always filled. |
| `fundFileNumber` | string | Form 13F file number of the filer (`028-04545`). |
| `sourceMode` | string | `fund` or `issuer` — which question produced the row. |
| `quarter` | string | `2026Q2`. Always filled. |
| `periodOfReport` | string | Quarter end, `YYYY-MM-DD`. Always filled. |
| `filedAt` | string | Filing date, `YYYY-MM-DD` UTC. Always filled. |
| `acceptedAt` | string | When EDGAR accepted the submission, ISO 8601 UTC. `fund` mode only. |
| `accessionNumber` | string | The filing this number comes from. Always filled. |
| `formType` | string | `13F-HR` or `13F-HR/A`. |
| `isAmendment` | boolean | True for a 13F-HR/A. |
| `amendmentType` | string | `restatement`, `new holdings` or the filed wording; empty for an original. |
| `reportType` | string | See [Reference](#columns-of-an-information-table). |
| `nameOfIssuer` | string | Issuer as the manager filed it; spellings differ between managers. Always filled. |
| `titleOfClass` | string | Share class as filed (`COM`, `CL A`, `NOTE 2.5% 2030`). |
| `cusip` | string | 9-character CUSIP — the reliable key for a security. Always filled. |
| `putCall` | string | `PUT` or `CALL` for an option position, empty otherwise. |
| `shares` | number | `sshPrnamt`: a share count when `sharesOrPrincipalType` is `SH`. Always filled. |
| `sharesOrPrincipalType` | string | `SH` or `PRN`. |
| `valueUsd` | number | Position value in whole US dollars, normalised across the 2023 form change. Always filled. |
| `valueAsFiled` | number | The `value` figure exactly as filed. |
| `valueUnitAsFiled` | string | `USD`, or `thousands of USD` for a quarter before 2023. |
| `pctOfPortfolio` | number | `valueUsd` as a percentage of `portfolioValueUsd`. |
| `investmentDiscretion` | string | `SOLE`, `DFND` or `OTR`. |
| `otherManager` | string | The included managers this position belongs to, resolved from the cover page to their names. Empty when the filing includes no other manager — some filers still fill the column with a placeholder (`0`, `NONE`), which is read as empty. |
| `votingSole`, `votingShared`, `votingNone` | number | Voting authority as filed. |
| `portfolioValueUsd` | number | `tableValueTotal` of the filing, in dollars. |
| `holdingsReported` | number | `tableEntryTotal`: how many lines the manager says the table has. |
| `otherManagersCount` | number | Included managers on the cover page. |
| `prevShares`, `prevValueUsd` | number | Last quarter's totals for the security; only with `comparePreviousQuarter`. |
| `sharesChange`, `sharesChangePct` | number | Change in the share total; only with `comparePreviousQuarter`. |
| `changeType` | string | `new`, `increased`, `reduced`, `unchanged` or `sold`; only with `comparePreviousQuarter`. |
| `found` | boolean | False on a marker row for a manager with no filing for the quarter. On such a row the filing and position columns above (`filedAt`, `accessionNumber`, `nameOfIssuer`, `cusip`, `shares`, `valueUsd` and the rest) are null, and `url` points at the manager's filing list on EDGAR instead of a filing. |
| `notFoundReason` | string | Why that manager produced no holdings. |
| `lineIndex` | number | Position of the line on the information table. |
| `infoTableUrl` | string | The XML that was parsed. |
| `url` | string | The filing index page on sec.gov. Always filled; on a marker row it is the manager's filing list instead (see `found`). |
| `fetchedAt` | string | Read time, ISO 8601 UTC. Always filled. |

Dataset views: **Holdings**, **Quarter-over-quarter changes**, **Filings behind the rows**.

### Use it from code / agents

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~sec-13f-fund-holdings/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"fund","funds":["Berkshire Hathaway Inc"],"quarter":"latest","maxItems":25}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/sec-13f-fund-holdings').call({ mode: 'issuer', issuer: '037833100', quarter: 'latest', maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/sec-13f-fund-holdings").call(run_input={"mode": "fund", "funds": ["0001350694"], "quarter": "latest", "comparePreviousQuarter": True, "maxItems": 25})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to Claude / Cursor / any MCP client and call the `yadroo/sec-13f-fund-holdings` tool with the same JSON input. The four knobs an agent needs are `mode`, `funds` or `issuer`, `quarter` and `maxItems`.

### Pricing

Pay per event: **$0.001 per run start + $0.002 per dataset row**. Every run is charged the start event, including one that finds nothing, and every row written to the dataset is charged — marker rows for a manager with no filing for the quarter (`found: false`) included.

| Run | Cost |
|---|---|
| 25 largest positions of one manager | $0.001 + 25 × $0.002 = **$0.051** |
| 50 rows (the default cap) | $0.001 + 50 × $0.002 = **$0.101** |
| 20 holders of one security | $0.001 + 20 × $0.002 = **$0.041** |
| A manager with no filing for the quarter (1 marker row) | $0.001 + 1 × $0.002 = **$0.003** |

`maxItems` is the hard cap on rows and therefore on cost. `minValueUsd` and `issuerFilter` run on the parsed filing, before anything is written, so a "top 25 positions" answer costs 25 rows and not the 4,000 lines the manager filed. The run also stops at your **Maximum cost per run** and keeps the rows you already paid for, ending with "Stopped at your spending limit: N rows delivered" — verified on 2026-10-10.

### Limits & FAQ

- **Speed, measured in the cloud on 2026-10-10**: a one-manager run (resolve the name, read the submissions index, the cover page and the information table) delivered 50 rows in 4–5 seconds; an issuer-mode run delivered 20 holder rows in 5 seconds. Requests run at **5 per second across all sec.gov hosts**, half of the 10 per second the SEC's fair-access policy allows an automated client, with retries counted against the same budget. One manager and one quarter cost 4 requests; each additional filing costs 3; each holder in issuer mode costs 2. A wide issuer-mode run measured on the same day delivered **1,244 rows from 77 filings in 44 seconds** (about 1,800 rows and 225 sec.gov requests per minute) before its 60-second timeout stopped it cleanly. Past any burst allowance the pace holds: a 253-second run opened **624 filings with 1,255 sec.gov requests — 301 requests per minute, five per second sustained — with no throttling, no refused request and no lost filing**, and ended with an honest stop status. At that pace the default 900-second run timeout fits roughly a thousand filings — far more than the 5,000-row cap allows — so a normal run is limited by `maxItems`, not by time.
- **A run stops before its timeout rather than dying in it**: when the deadline comes close the actor stops opening filings, saves what it has read and ends successfully with "Stopped before the run timeout: N rows saved" — verified on 2026-10-10.
- **The SEC's limit is per client address.** The actor stays at half the documented rate whatever the run size, so a long run is as polite as a short one. If sec.gov does throttle the server a run is on (HTTP 429, or 403 straight away), the run says so and asks you to start again in a few minutes instead of hammering the source.
- **The data is 45 days stale by design.** A quarter is only on file once its filing deadline has passed, and managers amend filings for months afterwards. `latest` always picks the newest quarter whose deadline has passed.
- **XML from 2013 Q2 onwards.** Earlier 13F filings carry a plain-text table this actor does not parse; an earlier quarter is refused with that explanation.
- **Values before 2023 were filed in thousands of dollars.** `valueUsd` is always whole dollars, and `valueAsFiled` + `valueUnitAsFiled` keep the original figure, so a 2022 quarter and a 2026 quarter can be compared directly. When the implied price per share of a line is impossible, the run says so in its status and the row keeps both figures.
- **Only US-listed 13(f) securities.** Short positions, cash, most bonds and most non-US holdings never appear on a 13F, and a manager may withhold positions under a confidential-treatment request. The filing's own `tableEntryTotal` and `tableValueTotal` are in every row (`holdingsReported`, `portfolioValueUsd`) so you can see what the manager said it reported.
- **One CUSIP can appear on several lines of one filing** — one line per included manager, with `otherManager` naming them. The lines are kept exactly as filed and never summed; the quarter-over-quarter comparison adds them up per security.
- **Issuer mode cannot enumerate a widely held security completely.** EDGAR full-text search answers at most 10,000 hits per query, and there is no server-side sort by position size, so managers arrive filing by filing, newest filing first — not "the largest holders first". The run says when the hit cap was reached.
- **A manager with nothing on file is not an error**: it produces one row with `found: false` and the reason, and the run status names it. A manager that did file but outside a `sinceHours` window is a different case and produces no row at all — the status names the filing it skipped, so a scheduled monitoring run that finds nothing new pays for no rows. An unknown or ambiguous manager name is an input error with the candidates listed, not a silently different fund.
- **`mode` and `sortBy` are strict dropdowns**: the platform refuses a value outside `fund` / `issuer` and `valueDesc` / `asFiled` before the run starts, with the allowed values in the message. `funds`, `issuer`, `issuerFilter`, `quarter` and `fields` are free text and are matched as described above.
- Questions or problems: open an issue on the Issues tab of this actor.

***

Made by **Yadroo**. Sibling actors: [sec-form4-insider-trades](https://apify.com/yadroo/sec-form4-insider-trades), [sec-edgar-filings](https://apify.com/yadroo/sec-edgar-filings), [sec-company-financials](https://apify.com/yadroo/sec-company-financials), [sec-form-d-offerings](https://apify.com/yadroo/sec-form-d-offerings), [us-treasury-yields](https://apify.com/yadroo/us-treasury-yields).

# Actor input Schema

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

Two different questions, one per run. `fund` starts from a list of institutional managers and returns the positions each of them reported on its information table for the quarter. `issuer` starts from one security and returns every manager that reported it, so you see the holder side of the same data. Everything else below says which quarter, which positions to keep and how much detail to add.

## `funds` (type: `array`):

Used by `fund` mode: either a CIK (`0001067983`, or `1067983` - leading zeros are added for you) or the manager name as EDGAR spells it (`Berkshire Hathaway Inc`). Names are matched loosely: case, extra spaces, punctuation and legal suffixes are ignored. A name that fits several filers stops the run and lists the candidates with their CIKs instead of picking one. A manager with no 13F filing for the quarter gets one row with `found: false` and a reason.

## `issuer` (type: `string`):

Used by `issuer` mode: a 9-character CUSIP is the exact way to ask (`037833100` = Apple common stock, `67066G104` = NVIDIA), because managers key their tables by CUSIP. An issuer name is matched as a phrase against the filed `nameOfIssuer` column instead (`NVIDIA CORP`) - useful without a CUSIP, but spellings differ between managers. Tickers are not in a 13F table and are refused with that explanation.

## `quarter` (type: `string`):

Which quarter end to report, written any of these ways: `2026Q2`, `2026-Q2`, `Q2 2026`, `2026-06-30`. `latest` or an empty value means the most recent quarter whose 45-day filing deadline has already passed, which is what most managers have on file today. Information tables are XML from the second quarter of 2013 onwards; an earlier quarter is refused with a clear message because those filings carry a plain-text table this actor does not parse.

## `issuerFilter` (type: `array`):

Optional, `fund` mode: keep only positions whose CUSIP or issuer name matches one of these values - the fast way to answer "does this manager still hold that stock?" over a list of managers. CUSIPs match exactly, names match when the filed `nameOfIssuer` contains the value, case-insensitively. Leave empty for the whole portfolio.

## `minValueUsd` (type: `number`):

Drop positions reported below this dollar value. Values filed before 2023 are stated in thousands on the form; they are converted to dollars first, so one threshold works across quarters. 0 keeps everything.

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

Sorting happens inside each filing, which is where `maxItems` cuts: `valueDesc` with `maxItems: 25` gives the manager's 25 largest reported positions, `asFiled` keeps the table order (roughly alphabetical by issuer for most filing agents). In `issuer` mode managers arrive filing by filing, newest filing first, and the sort applies within each filing.

## `comparePreviousQuarter` (type: `boolean`):

Adds `prevShares`, `prevValueUsd`, `sharesChange`, `sharesChangePct` and `changeType` (new, increased, reduced, unchanged, sold) to every row by reading the same manager's filing for the quarter before. Positions the manager reported last quarter and no longer reports come back as extra rows with `shares: 0` and `changeType: "sold"`, because an exit is usually the point of the comparison. Costs one extra filing per manager and is off by default.

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

Managers correct quarters after the fact. A restatement amendment replaces the original table for that manager and quarter, so only the newest restatement is used; an amendment that only adds holdings is reported next to the original rather than instead of it. Every row names the `accessionNumber`, `formType` and `amendmentType` it came from, so a number can always be traced to one filing. Turn this off to see only the original 13F-HR.

## `sinceHours` (type: `integer`):

Optional: skip filings EDGAR accepted longer ago than this. Useful on the three days around a 45-day deadline, when several hundred managers file and you only want what is new since the last run. In `fund` mode the acceptance timestamp is used, in `issuer` mode only the filing date is available, so the window is rounded to whole days there. Leave empty for every filing of the quarter.

## `onlyNew` (type: `boolean`):

Skips rows this task already delivered in an earlier run. A position is remembered by manager CIK, quarter, accession number, the line's position on the information table and the CUSIP, so an amended filing of a quarter you already pulled comes through as new while an unchanged re-run stays empty. The memory belongs to the task, so a new task starts empty.

## `fields` (type: `array`):

Optional: the columns you want, in your order. The always-filled columns you do not list come first (manager, quarter, period, filing, issuer, CUSIP, shares, value, url, fetchedAt), then your list in the order you wrote it. Leave empty for the full row. An unknown column name is refused with the list of valid ones.

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

Hard cap on dataset rows, and on what you pay for. The largest managers report several thousand positions in one filing, so a cap is how you keep a run small: 25-50 rows with `sortBy: valueDesc` answers most questions. The cap applies per run across all managers in `funds`.

## Actor input object example

```json
{
  "mode": "fund",
  "funds": [
    "Berkshire Hathaway Inc"
  ],
  "issuer": "037833100",
  "quarter": "latest",
  "minValueUsd": 0,
  "sortBy": "valueDesc",
  "comparePreviousQuarter": false,
  "includeAmendments": true,
  "onlyNew": false,
  "maxItems": 50
}
```

# Actor output Schema

## `results` (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 = {
    "funds": [
        "Berkshire Hathaway Inc"
    ],
    "issuer": "037833100",
    "quarter": "latest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/sec-13f-fund-holdings").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 = {
    "funds": ["Berkshire Hathaway Inc"],
    "issuer": "037833100",
    "quarter": "latest",
}

# Run the Actor and wait for it to finish
run = client.actor("yadroo/sec-13f-fund-holdings").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 '{
  "funds": [
    "Berkshire Hathaway Inc"
  ],
  "issuer": "037833100",
  "quarter": "latest"
}' |
apify call yadroo/sec-13f-fund-holdings --silent --output-dataset

```

## MCP server setup

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

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/wZF1iopA18ILMt9TA/builds/wKg5eJC4o7pYe2zT5/openapi.json