# 📊 SEC Form N-PORT — Mutual Fund Holdings & Risk Data (`nexgendata/sec-form-nport-mutual-fund-holdings`) Actor

Pull mutual fund / ETF portfolio holdings from SEC EDGAR Form N-PORT public filings. CUSIP/ISIN/ticker, value USD, % of NAV, asset/issuer category, securities lending, debt coupon/maturity, fund risk metrics. Morningstar Direct / Refinitiv Lipper / Bloomberg fund-holdings alternative.

- **URL**: https://apify.com/nexgendata/sec-form-nport-mutual-fund-holdings.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 n-port holding records

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

## 📊 SEC Form N-PORT — Mutual Fund Holdings & Risk Data

**Every position, every fund, every quarter — straight from the SEC.** Pull machine-readable mutual fund, ETF, and closed-end fund portfolio holdings from SEC EDGAR Form N-PORT public filings. Filter by fund CIK, by issuer ticker, or by recent filings. Each record carries the full security identifier set (CUSIP / ISIN / ticker / LEI), the position size and currency, fair value in USD, percent of NAV, asset and issuer categorization, country of investment, securities-lending status, debt coupon and maturity, and a live link back to the source XML. **Institutional fund-holdings analytics at a fraction of Morningstar Direct, Refinitiv Lipper, or ICI Research pricing.**

This actor reads the same primary data set that powers $25,000+ per-seat enterprise products. Every U.S. registered investment company has been required to file Form N-PORT monthly since 2018; the third month of each quarter is made public 60 days after period end. The filings are public. The XML schema is documented. Nobody has built a clean institutional-grade API around it — until now.

---

### Why this actor beats the alternatives

| Feature | This Actor | Morningstar Direct | Refinitiv Lipper for IM | Bloomberg Fund Holdings | ICI Research |
|---|---|---|---|---|---|
| **Coverage** | ALL NPORT-P filings (~10,000 funds, ~50M holdings/yr) | Curated subset (~30,000 share classes) | Enterprise client list | Bloomberg-licensed coverage | Aggregate stats only |
| **Refresh latency** | Real-time (within hours of EDGAR public release) | Monthly | Monthly | Monthly | Quarterly |
| **Pricing** | Pay-per-holding ($0.05 / record) | $17,500+/yr per seat | Enterprise contract ($25K+/yr) | Bloomberg Terminal ($24K/yr) | Subscription |
| **Filter by fund CIK** | ✅ Direct | ✅ | Manual | ✅ | ❌ |
| **Filter by issuer (cross-fund)** | ✅ One query | Limited | ✅ | ✅ | ❌ |
| **Filter by recent filings** | ✅ daysBack window | ❌ | ❌ | ❌ | ❌ |
| **Fund-level risk metrics (DV01, NAV)** | ✅ Included on every row | ✅ | ✅ | ✅ | Aggregate |
| **Securities lending status** | ✅ Per position | ✅ | Limited | ✅ | ❌ |
| **Debt coupon / maturity** | ✅ Per debt position | ✅ | ✅ | ✅ | ❌ |
| **Output format** | JSON / CSV / Excel | Excel/Workspace only | Workspace only | Excel / API tier | PDF reports |
| **API / scriptable** | ✅ REST + SDK | Limited | Limited | Limited | ❌ |
| **Setup time** | < 1 minute | 4-8 weeks | 4-8 weeks | 4-8 weeks | N/A |
| **Source** | SEC EDGAR (primary) | SEC EDGAR + Morningstar overlay | SEC EDGAR + Refinitiv overlay | SEC EDGAR + Bloomberg overlay | ICI surveys + SEC |

---

### What you get

Every dataset item is a single portfolio holding with these fields:

* **Fund identifiers:** `fund_cik`, `fund_name`, `fund_series_id`, `fund_series_name`, `fund_lei`
* **Filing context:** `filing_id` (EDGAR accession), `filing_date`, `report_period_end`, `net_assets_usd`
* **Security identifiers:** `security_name`, `security_title`, `security_lei`, `cusip`, `isin`, `ticker`, `other_identifier`, `other_identifier_desc`
* **Quantities + valuation:** `balance`, `units` (NS / PA / OU), `currency`, `value_usd`, `pct_of_nav`
* **Categorization:** `asset_category` (equity-common / equity-preferred / debt / asset-backed / loan / municipal-bond / derivative / repurchase-agreement / etc.), `issuer_category` (corporate / foreign-government / us-treasury / municipal / etc.), `investment_country`, `is_restricted_security`, `fair_value_level` (FASB ASC 820 tier 1/2/3), `payoff_profile` (long / short / N/A)
* **Debt-only fields:** `coupon_rate_pct`, `maturity_date`, `is_default`, `interest_in_arrears`, `is_paid_in_kind`
* **Securities lending:** `securities_lending_loan_value_usd`, `is_loaned_by_fund`, `is_cash_collateral`
* **Audit trail:** `_source_url` — direct link to the EDGAR primary_doc.xml for that filing

Every field is normalized — no parsing free-text "EC" vs "Equity Common" vs "Common Equity" across thousands of funds. Asset and issuer categories are mapped from the raw N-PORT codes into a stable, queryable taxonomy.

---

### Use cases

* **Multi-asset allocators / fund-of-funds managers** — see exactly what your underlying funds hold, audit overlap, rebuild your true look-through exposures
* **ESG fund managers** — verify your competitors' green / sustainable / climate fund holdings against marketing claims, audit greenwashing
* **Activist hedge fund desks** — see which mutual funds hold your target company in concentrated positions; size potential opposition / support
* **Quant funds / smart-beta strategists** — backtest the holdings-overlap factor, replicate active fund factor exposures, build mutual-fund-mimicking ETFs
* **Securities-lending desks** — see which funds make stocks available for borrow, identify the deepest pools of inventory by issuer
* **Credit research analysts** — see which mutual funds hold a specific bond (CUSIP / ISIN); track exit risk from fund-flow pressure
* **Compliance / risk teams** — verify your in-house fund-holdings database vs the SEC primary source; reconcile NAV and total-assets discrepancies
* **Academic research** — replicate published studies (Cremers / Petajisto active share, Jiang / Verbeek holding overlap), build longitudinal panels

---

### Quick start

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/sec-form-nport-mutual-fund-holdings").call(
    run_input={
        "mode": "by_cik",
        "cik": "820892",          ## Fidelity Magellan Fund
        "maxHoldings": 500,
        "proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]},
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        item["security_name"], "|",
        item.get("ticker") or item.get("cusip"), "|",
        f"${item['value_usd']:,.0f}", "|",
        f"{item['pct_of_nav']:.2f}% of NAV"
    )
````

#### Modes

- `recent_filings` — scan all NPORT-P filings filed in the last `daysBack` days (default 30). Best for tracking the quarterly public-release rush in Feb/May/Aug/Nov.
- `by_cik` — pull every public holdings filing for one fund / fund-family. Requires `cik`. Use this for fund-of-funds look-through or peer-fund comparisons.
- `by_issuer` — cross-fund view: every position from every fund in a single issuer. Accepts a ticker (`AAPL`) or company-name substring. Use this for ownership-base analysis or for credit research on a specific bond issuer.

***

### Pricing — premium institutional tier

This actor uses **Pay-Per-Event** billing:

| Event | Price |
|---|---|
| Actor start | **$0.005** per run |
| N-PORT holding record | **$0.05** per record returned |

Typical query costs:

- **Single-fund full quarter** (300-1,000 holdings) — **$15–$50**
- **Single-issuer across all funds, one quarter** (200-1,000 holdings) — **$10–$50**
- **One fund-family quarterly audit** (~5,000 holdings) — **$250**
- **Smoke-test query** (`maxHoldings: 50`) — **$2.50**

We recommend setting a daily account cap of **$1,000 / 20,000 holdings** to bound spend on accidental large pulls.

Compared with Morningstar Direct ($17,500/yr) or a Bloomberg Terminal seat ($24,000/yr), a $250 single-audit query pays for itself the first time you avoid a contract renewal.

***

### Related actors from NexGenData

Cross-reference fund holdings with proxy voting, insider transactions, institutional holdings, and corporate events:

| Actor | What it does |
|---|---|
| [SEC Form N-PX Mutual Fund Proxy Votes](https://apify.com/nexgendata/sec-form-npx-mutual-fund-proxy-votes) | Every proxy vote cast by every mutual fund — the canonical N-PX dataset |
| [SEC Form 13F Holdings Tracker](https://apify.com/nexgendata/sec-form-13f-holdings-tracker) | Quarterly 13F institutional manager holdings |
| [13F Holdings Delta Tracker](https://apify.com/nexgendata/13f-holdings-delta-tracker) | Quarter-over-quarter changes in 13F filings |
| [SEC Schedule 13D/G Activist Tracker](https://apify.com/nexgendata/sec-schedule-13dg-activist-tracker) | 5%+ activist filings and amendments |
| [SEC Form 4 Insider Tracker](https://apify.com/nexgendata/sec-form4-insider-tracker) | CEO / CFO / Director / 10%-owner buys & sells |
| [ETF Holdings Tracker](https://apify.com/nexgendata/etf-holdings-tracker) | Daily ETF holdings snapshots |
| [Sovereign Wealth Fund Tracker](https://apify.com/nexgendata/sovereign-wealth-fund-tracker) | Public disclosures from SWFs globally |
| [Australia ASIC Form 605 Substantial Holdings](https://apify.com/nexgendata/australia-asic-form-605-substantial-holdings) | ASX-equivalent of US 13F |

The whole NexGenData fleet — 200+ premium financial / governance / market actors at [apify.com/nexgendata?fpr=2ayu9b](https://apify.com/nexgendata?fpr=2ayu9b).

***

### FAQ

**Q: Is this real SEC data, or a third-party aggregator?**
A: 100% primary-source EDGAR. We pull directly from `https://www.sec.gov/Archives/edgar/data/...` — the same XML files the SEC publishes. There is no third-party scraper, no rewrite layer. Your `_source_url` field points at the exact `primary_doc.xml` we parsed.

**Q: How current is the data?**
A: NPORT-P (the public version of Form N-PORT) is released 60 days after the third month of each calendar quarter. So Q1 holdings (period ending March 31) become public May 30; Q2 (June 30) goes public August 29; Q3 (Sept 30) goes public Nov 29; Q4 (Dec 31) goes public March 1. Our `recent_filings` mode surfaces filings within hours of public release.

**Q: What about the monthly non-public filings?**
A: Months 1 and 2 of each quarter are filed but kept non-public for 60 days after the end of the *full* quarter. The SEC does not release them. Only NPORT-P (the third month of each quarter) is in EDGAR's public index. If you need monthly granularity, you'll have to wait for the next quarter's public release.

**Q: Why is `ticker` sometimes null?**
A: Form N-PORT requires CUSIP for U.S. securities and ISIN for non-U.S. securities, but ticker is optional. We populate ticker when it's in the `<identifiers>` block but fall back to CUSIP / ISIN / other-identifier. Join on CUSIP for ticker resolution if you have an OpenFIGI or Refinitiv mapping.

**Q: How are asset and issuer categories defined?**
A: We use the exact N-PORT codes from the SEC's filing instructions: `EC` (equity common), `DBT` (debt), `DERIV-EQ` (equity derivative), `RA` (repurchase agreement), `UST` (US Treasury), etc. We map each to a human-readable label (e.g. `equity-common`, `debt`, `equity-derivative`) and expose both fields so you can pivot on either.

**Q: Are derivatives included?**
A: Yes. N-PORT requires reporting of all open derivative positions including total return swaps, credit default swaps, FX forwards, interest rate swaps, futures, and options. The actor exposes the asset category (`derivative` family) and the payoff profile (long / short). For full derivative legs (counterparty, reference instrument, notional, etc.) check the related `<derivativeInfo>` block in the source XML — we extract the position-level summary; for full leg-level analytics, request a custom build.

**Q: What's the largest filing you can process?**
A: We parse the XML incrementally and bound output via `maxHoldings`. The largest filings we've parsed exceed 10,000 holdings in a single fund (Vanguard Total World Stock Index, BlackRock iShares MSCI ACWI). Set `maxHoldings` to bound output volume and cost.

**Q: How does this compare with the NexGenData N-PX Proxy Votes actor?**
A: N-PORT shows what funds *own*. N-PX shows what funds *vote*. The two together — holdings + voting record — are the canonical stewardship dataset. Run both as a sister-actor query for any fund family.

**Q: Can I get this data exported to Snowflake / BigQuery / S3?**
A: Yes. Apify's scheduled-run + dataset export to S3 / GCS / Snowflake is built in. Set up a quarterly scheduled task (Feb 28, May 29, Aug 28, Nov 28) and the data lands in your warehouse with no glue code.

**Q: Are records deduplicated within a run?**
A: Yes — per `(fund_cik, filing_id, cusip-or-isin-or-name)` tuple. Re-running the same query will not produce duplicate dataset rows for the same position.

**Q: Why is the per-record price $0.05?**
A: This is institutional-grade data with a buyer pool that pays $17,500–$25,000 per seat for the same content elsewhere. The $0.05 / record price keeps the actor affordable for one-off audits ($50 covers a 1,000-holding fund pull) while preserving margin on cross-fund issuer queries that institutions pay premium prices for. Compared to a Morningstar Direct seat, you'll break even on the first focused query.

***

### About NexGenData

NexGenData publishes 200+ premium financial-data, governance, and market actors on Apify — every major U.S. and global financial filing, market data feed, fund holdings, insider activity, and corporate-events source, all with consistent pay-per-event pricing and full audit trails to the primary regulator.

Browse the full fleet: [apify.com/nexgendata?fpr=2ayu9b](https://apify.com/nexgendata?fpr=2ayu9b)

Contact: contact@thenextgennexus.com

***

*SEC Form N-PORT is a public disclosure required of all U.S. registered investment companies under Rule 30b1-9 of the Investment Company Act of 1940. NPORT-P (the public version) is released 60 days after the third month of each calendar quarter. This actor reproduces the public record. No subscription is required to view N-PORT filings at SEC.gov; this product exists to make the data machine-readable, queryable, and reliably structured at institutional scale.*

# Actor input Schema

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

Which slice of NPORT-P (public N-PORT) filings to scan. `recent_filings` walks all NPORT-P submissions in the last `daysBack` days. `by_cik` pulls every NPORT-P filing for a specific fund CIK. `by_issuer` extracts every position across all funds that holds a specific issuer (ticker or company-name substring).

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

Look at NPORT-P filings filed within the last N days. Only used when `mode=recent_filings`. The public version (NPORT-P) is released 60 days after the third month of each calendar quarter — filings cluster in the months of March, June, September, and December.

## `cik` (type: `string`):

SEC CIK (Central Index Key) of the fund / fund-family. Required when `mode=by_cik`. Example: `820892` for Fidelity Magellan Fund, `1120925` for T. Rowe Price International Index Fund. Look up CIK at https://www.sec.gov/cgi-bin/browse-edgar.

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

Issuer whose positions you want to find across all funds. Accepts a US ticker (e.g. `AAPL`, `MSFT`) or a company-name substring (e.g. `Apple`, `Microsoft`). Required when `mode=by_issuer`. Matching is case-insensitive against the N-PORT `<name>` field.

## `maxHoldings` (type: `integer`):

Hard cap on total holding records pushed to the dataset (and metered for billing). A single multi-billion-dollar fund can hold 1,000-10,000+ positions per filing — set this to control cost. Default 1,000.

## `proxyConfiguration` (type: `object`):

Apify proxy configuration. SEC EDGAR has a polite 10 req/sec rate limit and a User-Agent requirement (we use `NexGenData/1.0 contact@thenextgennexus.com`). Residential proxy is recommended for sustained throughput.

## Actor input object example

```json
{
  "mode": "recent_filings",
  "daysBack": 30,
  "cik": "820892",
  "issuer": "Apple",
  "maxHoldings": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "mode": "recent_filings",
    "daysBack": 30,
    "cik": "820892",
    "issuer": "Apple",
    "maxHoldings": 200,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/sec-form-nport-mutual-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 = {
    "mode": "recent_filings",
    "daysBack": 30,
    "cik": "820892",
    "issuer": "Apple",
    "maxHoldings": 200,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/sec-form-nport-mutual-fund-holdings").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 '{
  "mode": "recent_filings",
  "daysBack": 30,
  "cik": "820892",
  "issuer": "Apple",
  "maxHoldings": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call nexgendata/sec-form-nport-mutual-fund-holdings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/sec-form-nport-mutual-fund-holdings",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📊 SEC Form N-PORT — Mutual Fund Holdings & Risk Data",
        "description": "Pull mutual fund / ETF portfolio holdings from SEC EDGAR Form N-PORT public filings. CUSIP/ISIN/ticker, value USD, % of NAV, asset/issuer category, securities lending, debt coupon/maturity, fund risk metrics. Morningstar Direct / Refinitiv Lipper / Bloomberg fund-holdings alternative.",
        "version": "0.0",
        "x-build-id": "Uwtxcl3xfcem8LrJv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~sec-form-nport-mutual-fund-holdings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-sec-form-nport-mutual-fund-holdings",
                "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/nexgendata~sec-form-nport-mutual-fund-holdings/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-sec-form-nport-mutual-fund-holdings",
                "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/nexgendata~sec-form-nport-mutual-fund-holdings/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-sec-form-nport-mutual-fund-holdings",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Query mode",
                        "enum": [
                            "recent_filings",
                            "by_cik",
                            "by_issuer"
                        ],
                        "type": "string",
                        "description": "Which slice of NPORT-P (public N-PORT) filings to scan. `recent_filings` walks all NPORT-P submissions in the last `daysBack` days. `by_cik` pulls every NPORT-P filing for a specific fund CIK. `by_issuer` extracts every position across all funds that holds a specific issuer (ticker or company-name substring).",
                        "default": "recent_filings"
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Look at NPORT-P filings filed within the last N days. Only used when `mode=recent_filings`. The public version (NPORT-P) is released 60 days after the third month of each calendar quarter — filings cluster in the months of March, June, September, and December.",
                        "default": 30
                    },
                    "cik": {
                        "title": "Fund CIK",
                        "type": "string",
                        "description": "SEC CIK (Central Index Key) of the fund / fund-family. Required when `mode=by_cik`. Example: `820892` for Fidelity Magellan Fund, `1120925` for T. Rowe Price International Index Fund. Look up CIK at https://www.sec.gov/cgi-bin/browse-edgar."
                    },
                    "issuer": {
                        "title": "Issuer ticker or company name",
                        "type": "string",
                        "description": "Issuer whose positions you want to find across all funds. Accepts a US ticker (e.g. `AAPL`, `MSFT`) or a company-name substring (e.g. `Apple`, `Microsoft`). Required when `mode=by_issuer`. Matching is case-insensitive against the N-PORT `<name>` field."
                    },
                    "maxHoldings": {
                        "title": "Max holding records",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on total holding records pushed to the dataset (and metered for billing). A single multi-billion-dollar fund can hold 1,000-10,000+ positions per filing — set this to control cost. Default 1,000.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. SEC EDGAR has a polite 10 req/sec rate limit and a User-Agent requirement (we use `NexGenData/1.0 contact@thenextgennexus.com`). Residential proxy is recommended for sustained throughput.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
