# 13F Portfolio Tracker (`zinin/thirteen-f-tracker`) Actor

Track institutional managers (hedge funds, family offices) by SEC CIK or name and get their recent 13F-HR quarterly filings — form, filing date, accession number and an EDGAR link. Official SEC data, free, no API key or login.

- **URL**: https://apify.com/zinin/thirteen-f-tracker.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** News, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 holding founds

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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## 13F Portfolio Tracker — New Filings by Institutional Manager

**Did a hedge fund or family office just file their quarterly 13F?** Point this Actor at a list of institutional managers — by SEC CIK or by name — and get back every 13F-HR filing that landed in your lookback window, straight from official SEC EDGAR data. No API key, no browser, no login.

### Who is this for

- **Investors & analysts** — an alert-ready feed of 13F-HR filings for a watchlist of managers, without babysitting the EDGAR full-text search UI.
- **Journalists & researchers** — track when a specific fund last disclosed its quarterly holdings.
- **Fintech builders** — a clean, structured 13F filings feed to wire into a bot, dashboard or n8n workflow.
- **Allocators & LPs** — monitor filing cadence for managers you track or invest alongside.

### What you get

- **A structured filings feed** — resolved company name, filing count in your window, and the filings themselves (form, filing date, accession number, EDGAR link) — no scraping, no rendering.
- **A confident name→CIK match, not a guess.** A manager name only resolves to a filer when the name similarity clears a 0.85 bar; below that, you get a short list of the closest candidates with their scores instead of a silently wrong company's holdings.
- **CIK input skips resolution entirely** — a 10-digit CIK is unambiguous and goes straight to the filing history.
- **Match evidence on every resolved row** — `matchConfidence` and `matchBasis` tell you whether the row came from an exact CIK or a scored name match, and how confident that match was.
- Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export to JSON/CSV/Excel, or push straight into your own pipeline.

### Why it matters

13F-HR is the SEC form that discloses an institutional investment manager's U.S. equity holdings each quarter — the primary public source for "what did this fund buy/sell." EDGAR's own UI has no manager-list mode and no API key/quota system to build on top of — you either poll the website by hand or write your own name→CIK resolver and pagination logic. This Actor does that resolution once per run and hands back one row per manager, ready to filter, alert on, or pipe into a dataset.

### How to run it

1. Click **Try for free** — no card needed on the free plan.
2. Paste managers into **Managers**, one per row — a 10-digit SEC CIK (most reliable) or a manager name.
3. Press **Start** and read the results from the dataset — UI, API or webhook.

### Pricing

Pay-per-event: **$0.005 per run start + $0.005 per result**. 100 managers cost about **$0.51**; 1,000 managers about **$5.01**.

A manager that could not be resolved to a single filer — a bad CIK, no name match, or a name that matches several filers too closely to call — is still returned so you can see why, and it is **not** charged for. You pay for an identified filer's filings, not for an attempt.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `managers` | array of strings | Institutional managers to watch — a 10-digit SEC CIK (e.g. `0001067983`, used as-is) or a manager name resolved against EDGAR's filer index (e.g. `Bridgewater Associates`). A name that matches several filers too closely to call returns the shortlist with similarity scores instead of picking one — use the CIK, or the filer's full name, for anything generic like `Capital Management`. Required. |
| `sinceDays` | integer | Only include 13F filings from the last N days. Default 365, max 3650 (10 years). |
| `maxConcurrency` | integer | Parallelism (1–10, default 5). SEC EDGAR's documented rate limit is 10 requests/second. |

```json
{
    "managers": ["0001067983", "0001350694", "Renaissance Technologies"],
    "sinceDays": 365
}
````

### Output

One item per manager. This is a real row from a real run:

```json
{
    "manager": "0001067983",
    "cik": "0001067983",
    "companyName": "BERKSHIRE HATHAWAY INC",
    "found": true,
    "matchConfidence": 1,
    "matchBasis": "cik",
    "candidates": [],
    "filingsCount": 5,
    "recentFilings": [
        {
            "form": "13F-HR",
            "filedAt": "2026-05-15",
            "accessionNumber": "0001193125-26-226661",
            "url": "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=0001067983&type=13F"
        }
    ],
    "summary": "BERKSHIRE HATHAWAY INC (CIK 0001067983) — 5 13F filings in the last 365 day(s), most recent 13F-HR on 2026-05-15. Resolved from the CIK given, exact.",
    "checkedAt": "2026-07-26T13:23:45.028Z"
}
```

| Field | Description |
|-------|-------------|
| `manager` | The CIK or name you passed |
| `cik` / `companyName` | The resolved filer's CIK and name on EDGAR |
| `found` | Whether this manager resolved to exactly one filer |
| `matchConfidence` | `1` for a CIK given outright; the name-similarity score (0–1) for a name match |
| `matchBasis` | `cik`, `name`, or `ambiguous` (see below) |
| `candidates` | Empty on a confident match. On an ambiguous name, the shortlist of closest filers instead — `cik`, `name`, `score` for each |
| `filingsCount` / `recentFilings` | How many 13F-HR filings landed in `sinceDays`, and the filings themselves |
| `summary` | Human-readable recap, including how the manager was matched |
| `error` | Present only when `found: false` — why (bad CIK, no name match, or ambiguous — see FAQ) |

An unresolvable manager (bad CIK, no name match, or a name matching several filers below the 0.85 confidence bar) returns `found: false` with an `error` explaining why — never a guessed or partial row.

#### Need the rest of the picture?

These run on the same account, take the same shape of input and bill the same way, so they slot into an existing pipeline without new plumbing.

| Actor | What it does |
|---|---|
| [Insider Trading Tracker](https://apify.com/zinin/insider-trading-tracker) | Track insider stock trades — SEC Form 3/4/5 filings — for any list of tickers |
| [SEC Filing Watcher](https://apify.com/zinin/sec-edgar-watcher) | Watch stock tickers for new SEC filings — 10-K, 10-Q, 8-K, S-1 and more |
| [AI Crawler Access Checker](https://apify.com/zinin/ai-crawler-access-checker) | Check which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended & more) can access your website |
| [B2B Lead Enricher](https://apify.com/zinin/b2b-lead-enricher) | Turn a list of company websites into sales-qualified lead cards: detected tech stack, a rough revenue… |
| [Clinical Trials Monitor](https://apify.com/zinin/clinical-trials-monitor) | Watch conditions, drugs or sponsors for new and updated clinical trials |

### FAQ / Limitations

**Does it need an API key or login?** No — EDGAR full-text search and `submissions/CIK*.json` are public SEC EDGAR endpoints.

**Does this parse the actual holdings (stocks, share counts)?** Not in v0.1 — this Actor lists the 13F-HR *filings themselves* (form, date, accession number, EDGAR link), not the parsed information-table holdings inside each filing. Use the `url` to open the manager's filing list on EDGAR and drill into a specific filing's information table.

**Why is the `url` the same for every filing of a manager?** A 13F-HR's payload is an XML information table, not a single readable primary document — so v0.1 links to the manager's own filing list on EDGAR (`browse-edgar?...&type=13F`) rather than guessing at a per-filing document path.

**Can I look up a manager by name instead of CIK?** Yes — a name resolves to a filer only when EDGAR's own similarity score against that filer's name clears 0.85. Below that bar, you get `found: false` with a `candidates` shortlist of the closest filers and their scores, instead of a confident-looking row for the wrong fund. A generic name like "Capital Management" is exactly the case this guards against — for an unambiguous result, give the CIK, or the filer's full legal name.

**What happens when a name is ambiguous?** The row returns `found: false`, `matchBasis: "ambiguous"`, and `candidates` — each with `cik`, `name` and its similarity `score` — so you can re-run with whichever CIK is the right one, or with the filer's full name.

**How fresh is the data?** As fresh as EDGAR itself — filings usually appear within minutes of acceptance.

**Can I call it from an AI agent?** Yes — it's a standard Apify Actor, callable via the Apify API or the Apify MCP server.

**What this is NOT.** Not investment advice, and not a parser of a fund's actual stock positions in v0.1 — it tells you a 13F-HR was filed, when, and by whom, and links you to it.

Found a wrong result, or need a doubtful match resolved differently? Open an issue on this Actor's page.

***

Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin).

# Actor input Schema

## `managers` (type: `array`):

Institutional managers to watch — each entry is either a 10-digit SEC CIK (e.g. `0001067983` for Berkshire Hathaway, used as-is) or a manager name resolved against EDGAR's filer index (e.g. `Bridgewater Associates`). A name that matches several filers returns the shortlist with similarity scores instead of picking one, so use the CIK or the full filer name for anything generic like `Capital Management`.

## `sinceDays` (type: `integer`):

Only include 13F filings from the last N days.

## `maxConcurrency` (type: `integer`):

How many managers to process in parallel. SEC EDGAR's documented rate limit is 10 requests/second — keep this at or below 10.

## Actor input object example

```json
{
  "managers": [
    "0001067983",
    "0001350694",
    "Renaissance Technologies"
  ],
  "sinceDays": 365,
  "maxConcurrency": 5
}
```

# 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 = {
    "managers": [
        "0001067983",
        "0001350694",
        "Renaissance Technologies"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/thirteen-f-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 = { "managers": [
        "0001067983",
        "0001350694",
        "Renaissance Technologies",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zinin/thirteen-f-tracker").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 '{
  "managers": [
    "0001067983",
    "0001350694",
    "Renaissance Technologies"
  ]
}' |
apify call zinin/thirteen-f-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zinin/thirteen-f-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "13F Portfolio Tracker",
        "description": "Track institutional managers (hedge funds, family offices) by SEC CIK or name and get their recent 13F-HR quarterly filings — form, filing date, accession number and an EDGAR link. Official SEC data, free, no API key or login.",
        "version": "0.1",
        "x-build-id": "pCcWqoVJsTXZlBsds"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zinin~thirteen-f-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zinin-thirteen-f-tracker",
                "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/zinin~thirteen-f-tracker/runs": {
            "post": {
                "operationId": "runs-sync-zinin-thirteen-f-tracker",
                "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/zinin~thirteen-f-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-zinin-thirteen-f-tracker",
                "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": [
                    "managers"
                ],
                "properties": {
                    "managers": {
                        "title": "Managers",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Institutional managers to watch — each entry is either a 10-digit SEC CIK (e.g. `0001067983` for Berkshire Hathaway, used as-is) or a manager name resolved against EDGAR's filer index (e.g. `Bridgewater Associates`). A name that matches several filers returns the shortlist with similarity scores instead of picking one, so use the CIK or the full filer name for anything generic like `Capital Management`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sinceDays": {
                        "title": "Since (days)",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only include 13F filings from the last N days.",
                        "default": 365
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many managers to process in parallel. SEC EDGAR's documented rate limit is 10 requests/second — keep this at or below 10.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
