# TickerInside: the API reference for agents

> TickerInside is an open, machine-readable database of US ETF holdings, with the source and date of each holding. It serves the holdings of 5,423 US ETFs with their weights, which ETFs hold a stock and at what weight, and the overlap between any two stock ETFs. Static JSON, with no key or sign-up, and CORS open to any origin. The licence is CC BY 4.0: credit TickerInside with a link to the page the figure comes from wherever the medium allows a link, and by name where it does not; how you mark the link is up to you. It covers TickerInside's own contribution; the holdings in issuer files are facts as each issuer publishes them, so check the issuer's terms before bulk commercial reuse. The holdings history (/api/v1/history.json, /api/v1/history/) and the ETF flows computed from it (/api/v1/flows.json, /api/v1/flows.csv, /api/v1/flows/, /feeds/) have their own terms: https://tickerinside.com/legal/#history.

688 funds, the issuer layer, are read every weekday night from their issuers' own holdings files. 1,944 more, the SEC layer, are read from their latest SEC Form N-PORT filing, which is months older. 922 fixed income funds, 235 multi-asset funds and 1,363 derivative-based funds come from the same filings, and 131 trusts and pools from their own SEC filings. 140 funds from their sponsors' own files, too new for a Form N-PORT. Every fund file carries the date of its holdings. Where the price data has enough of a fund's or a stock's history, its file also carries its weekly returns over 156 weeks. The weeks are the same in every file, so any basket of them can be correlated. Each stock file also carries its line of the ETF ownership ledger: the share of the company's shares outstanding that the covered funds hold, at least, with the SEC's count and its date. The method is in https://tickerinside.com/api/v1/methods.json. The same data answers inside Claude, Cursor, VS Code and other MCP clients through the server at https://tickerinside.com/mcp.

Data through 2026-10-12. This file is rebuilt with the data every weekday night. It holds the rules for agents, a glossary, the installs, commands to try and the API reference with its examples. Then come the field dictionary, with the unit and licence of every field, the MCP tools, and the citation rule. The same reference cut into one file per section is listed in https://tickerinside.com/llms.txt.

## Rules for agents

1. Give `holdings_as_of` beside any holdings figure, `as_of` beside any price or return figure, and `cite_as` under it; link its page where you can (a computed answer's: `source.links[].page_url`), else name TickerInside. A page, app, dashboard or report you build on these figures shows "Data: TickerInside (CC BY 4.0)" linked to https://tickerinside.com/ or the figure's page (each file's `cite_html`) where they appear; the licence asks for it (https://tickerinside.com/attribution/).
2. Name the overlap measure: `by_weight`, `share_of_a` or `share_of_b`. VOO and QQQ overlap 54.0% by weight, yet 92.8% of QQQ is in tickers VOO also holds.
3. Null means missing, never zero.
4. /sec/ is for a stock, /fund/ for a fund, a US mutual fund class too (FXAIX). A line listed abroad (7203.JP) has no stock file: /sec/ gives its holders only (`coverage` `holders_only`), from the shard /holders/{c}.json.
5. /overlap?funds=a,b answers a pair, written or not, in one shape; on `too_large`, follow the address or tool its `message` names. The 15 pairs in index.json `written_comparisons` also have a /compare/ file and page.
6. In /history/, a restated step has no `entered`, `exited` or `moved`: use a default (`step.get("entered", [])`). `reverted` lists lines back one file after they left: an issuer file's glitch, not trades. Skip a key of digits and a letter that entered meanwhile at about the same weight: it stood in for the line.
7. The history and flows files are not CC BY 4.0 (https://tickerinside.com/legal/#history): fetch them per fund or security when asked, never on a schedule to store them; a feed reader may poll /feeds/fund/{t}.xml, /feeds/stock/{t}.xml and /feeds/flows.xml.
8. /quarterly/{ticker}.json: a fund's quarterly SEC reports; /history/{ticker}/{date}.json: every position of the latest on or before the date. Quote its `holdings_as_of`.
9. New data lands each weekday night: the build starts at 22:00 UTC and is due by 02:00 UTC. Each build changes status.json `built_at`; `as_of` changes only with new prices. Fetch the whole set and holders.json (5.3 MB) at most once per build, with a User-Agent that names your program.

## Glossary

- Issuer layer: the funds read each weekday night from their issuers' own files; `source_layer` issuer.
- SEC layer: the funds read from their latest SEC Form N-PORT filing, months older; `source_layer` sec_nport.
- Line listed abroad: a holding traded outside the US, keyed with its market (7203.JP is Toyota in Tokyo).
- Other layers: fixed income, multi-asset, derivative-based, trust, sponsor-file and prospectus funds: under /fund/ with `holdings_kind`, in full under /etf/ (index.json `tickers_bond`, etc.).
- Key scheme: how keys are written; scheme 2 adds the market to lines listed abroad (`aliases` maps old keys).

## Install in one line

- Remote MCP server, any MCP client: `https://tickerinside.com/mcp`
- Claude Code: `claude mcp add --transport http tickerinside https://tickerinside.com/mcp`
- Codex CLI: `codex mcp add tickerinside --url https://tickerinside.com/mcp`
- Gemini CLI: `gemini mcp add --transport http tickerinside https://tickerinside.com/mcp`
- Local MCP server, Node 20 or later: `npx -y tickerinside-mcp@latest`
- Agent skill: `npx skills add https://tickerinside.com`
- Claude Code plugin, inside a session (Claude Code 2.1.275 or later): `/plugin install tickerinside --marketplace https://tickerinside.com/.claude-plugin/marketplace.json`
- Claude Code plugin, from a shell: `claude plugin marketplace add https://tickerinside.com/.claude-plugin/marketplace.json`, then `claude plugin install tickerinside@tickerinside`
- Python client: `pip install tickerinside`
- A2A agent, any A2A 1.0 or 0.3 client: `https://tickerinside.com/.well-known/agent-card.json`
- AGENTS.md block to paste into a project: `https://tickerinside.com/AGENTS.md`

## Try it

Fetch the JSON with curl or fetch and parse it yourself.

```sh
# Which ETFs hold NVDA: fund, weight in percent, date of that fund's file
curl -sL https://tickerinside.com/api/v1/sec/nvda.json | python3 -c "import json;print(json.load(open(0))['holders'][:3])"
# VOO's largest holdings, heaviest first, weights in percent
curl -sL https://tickerinside.com/api/v1/fund/voo.json | grep -o '"[A-Z][^"]*":[0-9.]*' | sort -t: -k2 -gr | head -5
# The citation line for VOO, with the date of its holdings file
curl -sL https://tickerinside.com/api/v1/fund/voo.json | python3 -c "import json;print(json.load(open(0))['cite_as'])"
# Every endpoint, as a URL template
curl -sL https://tickerinside.com/api/v1/index.json | python3 -c "import json;print(json.load(open(0))['endpoints'])"
# VOO and QQQ: overlap by weight and the share of each held in common
curl -sL https://tickerinside.com/api/v1/compare/voo-vs-qqq.json | python3 -m json.tool | grep -A4 '"overlap"'
```

## API reference

The reference of https://tickerinside.com/api/, from its Markdown twin https://tickerinside.com/api/index.md, with each example in cURL, Python, the tickerinside client and JavaScript.

### What the API covers

Counted from the files of 2026-10-12.

The holdings are read from the issuers' own files and from SEC filings, linked to the stocks inside each fund, and served with no key.

- US ETFs covered: 5,423. 688 from five issuers' own files, read every weekday night, 1,944 from their latest SEC Form N-PORT filing, and 922 fixed income funds, 235 multi-asset funds, 1,363 derivative-based funds, 131 trusts and pools and 140 funds from their sponsors' files.
- Holdings rows: 666,827 positions, each with its weight and the date of its source.
- Securities held: 18,758, in the 690 issuer files, each with the funds that hold it.
- Fund pairs: 3,462,396, each measured from its two stock ETF files; 15 are also written comparisons. A pair with a fund from SEC filings compares portfolios dated months apart.
- Stocks with a file: 5,056, 4,676 of them with at least 110 of the 156 weekly returns.
- Data files: 8,474 JSON files, one GET each, every one dated.

### Quickstart

- Base URL: https://tickerinside.com/api/v1
- Authentication: none. No key, no account, no per-user quota.
- Format: JSON over HTTPS, UTF-8, CORS open to any origin.
- Updates: each weekday night. The build starts at 22:00 UTC and is due by 02:00 UTC; `built_at` in /api/v1/status.json gives the time of the last one. Files are cached five minutes and answer `304` to `If-None-Match`.

1. Request a file: which ETFs hold Nvidia. Tickers go in the path in lower case.

```sh
curl https://tickerinside.com/api/v1/sec/nvda.json
```

2. Read the answer. `holders` lists the funds read from their issuers' own files, heaviest first, as fund, weight in percent and the date of that fund's file. `holders_sec_nport` adds the funds known from SEC filings, dated to the quarter end each filing describes. A security listed outside the US has a key of its own with its market (7203.JP is Toyota in Tokyo) and no stock file: https://tickerinside.com/api/v1/sec/7203.jp.json answers with `coverage` `holders_only`, from the shard of its first character. How keys are written is under "How holdings are keyed", in Where the data comes from.

```json
{
  "ticker": "NVDA",
  "name": "Nvidia",
  "…": "24 more fields",
  "held_by": 177,
  "heaviest": ["GXPT", 19.82],
  "held_by_sec_nport": 569,
  "holders": [
    ["GXPT", 19.82, "2026-10-12"],
    ["VGT", 17.7869, "2026-08-31"],
    ["VUSG", 16.9219, "2026-10-13"],
    "… 174 more"
  ],
  "holders_sec_nport": [
    ["SMHX", 18.5624, "2026-06-30"],
    ["SMH", 17.5486, "2026-06-30"],
    "… 567 more"
  ],
  "…": "1 more field",
  "left_out": [],
  "…": "19 more fields"
}
```

3. Show the date and the source. Print `cite_as` under any figure you show. Credit TickerInside with a link to the page the figure comes from (`cite_as` gives it) wherever the medium allows a link, and by name where it does not. How you mark the link is up to you; `cite_html` is that link, ready to paste.

```text
TickerInside, Nvidia (NVDA), holders from each covered fund's own file and from SEC Form N-PORT filings, each dated, prices through 2026-10-12, https://tickerinside.com/stock/nvda/, CC BY 4.0
```

### Endpoints

All under https://tickerinside.com/api/v1, read with GET: the files, and five answers computed from them when asked. The field reference at the end documents every field of each.

Every endpoint is a GET, with no key to send. The files take nothing in, and the five computed answers take theirs in the query string, so there is no POST, PUT or DELETE. A path also works without `.json`: `/api/v1/fund/voo` answers with a `301` to `/api/v1/fund/voo.json`.

- `GET /index.json`: what exists, every covered ticker, the coverage counts and the date of the data. Start here. https://tickerinside.com/api/v1/index.json
- `GET /funds.json`: every fund, one line each: name, issuer, category, size, cost, position count and the address of its file. https://tickerinside.com/api/v1/funds.json, and the files of the funds without a page, linked from one page, the largest of known size first: https://tickerinside.com/api/files/
- `GET /universe.json`: the US-listed ETFs, how each is covered or why not yet, and the coverage measured, in one file of 451 KB. https://tickerinside.com/api/v1/universe.json
- `GET /fund/{ticker}.json`: one fund, its holdings with their weights and the date of their source, an issuer file or an SEC filing, then cost, returns, risk and weekly returns over 156 weeks where the data has them. A figure the data lacks is null, and so is a week without a return; with fewer than 110 weekly returns, `weekly` is an empty list, or null for a fund from SEC filings. It also answers a US mutual fund share class: FXAIX with its fund's holdings from its SEC Form N-PORT (`kind` `mutual_fund`), VFIAX with VOO's, the ETF class of the same fund (`share_class_of`); the list is /api/v1/mutual-funds.json. https://tickerinside.com/api/v1/fund/voo.json
- `GET /sec/{ticker}.json` (sec for security, not the SEC): one stock, which ETFs hold it and at what weight, from issuer files and from SEC filings, with returns, risk and its weekly returns over the same 156 weeks. Every stock in the price data with at least 110 weekly returns in those weeks has one. A stock with fewer has one when a fund read from an issuer file or a stock ETF from SEC filings holds it in a file dated since it listed, the price data has its closes since its listing, or a year of them, the last at most five sessions old, and Nasdaq Trader's directory lists it under its name: `weekly` is then an empty list and the figures over three and five years are null. Any other security a covered fund holds, a line listed abroad included, answers with `coverage` `holders_only`: its holders, each dated, and no prices. https://tickerinside.com/api/v1/sec/nvda.json
- `GET /holders.json`: the reverse index of the 690 issuer files: every security their funds hold, and which of them hold it, in one file of 5.3 MB. https://tickerinside.com/api/v1/holders.json
- `GET /holders/{c}.json`: holders.json cut by the first character of the key, a to z, or 0 for any other character (7203.JP is in 0.json, AZN.GB in a.json). It is the source of the holders-only answers under /sec/, for a security with no stock file, such as a line listed abroad. Any other address under /holders/ answers 404, reason `not_a_shard`. https://tickerinside.com/api/v1/holders/a.json
- `GET /securities.json`: every security the funds of those issuer files hold, with how many of them hold it and its largest weight. https://tickerinside.com/api/v1/securities.json
- `GET /identifiers.json`: FIGIs and SEC ids of each fund and stock, which outlive a ticker. CSV too. https://tickerinside.com/api/v1/identifiers.json
- `GET /ownership.json`: the ETF ownership ledger, how much of each stock the covered US ETFs hold, at least, and from how many funds, with the share of their money in the ten largest US companies. https://tickerinside.com/api/v1/ownership.json
- `GET /methods.json`: the methods ti-ownership/1 (ETF ownership), ti-ownership-index/1 and ti-overlap/1, with formulas, rules and test vectors. https://tickerinside.com/api/v1/methods.json
- `GET /ownership-index.json`: the ETF Ownership Index: each stock's figure and top three funds' share, market and sector lines. CSV too.
- `GET /ownership-index/history.json`: the index by close, 5 and 20 day changes (history terms).
- `GET /compare/{a}-vs-{b}.json`: a written comparison, overlap measured three ways and correlation, for the 15 pairs in index.json `written_comparisons`, in the order listed there (voo-vs-vti exists; vti-vs-voo answers 301 to it). Any other pair answers 404, reason `no_written_comparison`, and is measured from its two fund files. The pairs: voo-vs-vti, qqq-vs-vgt, schd-vs-schg, voo-vs-qqq, qqq-vs-qqqm, dgro-vs-schd, qqq-vs-spy, vig-vs-vym, voo-vs-vug, vt-vs-vti, qqqm-vs-schg, rsp-vs-spy, schd-vs-vym, schg-vs-vug, vgt-vs-xlk. https://tickerinside.com/api/v1/compare/voo-vs-vti.json
- `GET /overlap?funds={funds}`: the overlap of 2 to 10 funds, computed when asked with the MCP tools' code: two give the pair (overlap by weight, each fund's share in common, the largest shared holdings, correlation), three or more every pair ranked. Bond funds overlap by issuer; a fund holding no shares is set aside with the reason. CSV: /overlap.csv. https://tickerinside.com/api/v1/overlap?funds=VOO,QQQ
- `GET /lookthrough?portfolio={portfolio}`: the companies under a portfolio, each fund with its weight or amount after a colon, or none for equal weights, as the MCP tool get_etf_portfolio_lookthrough gives them; `top` and `currency` too. CSV: /lookthrough.csv. https://tickerinside.com/api/v1/lookthrough?portfolio=VOO:60,QQQ:40
- `GET /batch?funds={funds}`: up to 10 fund files in one answer, keyed by ticker, each as /fund/ answers it, with the tickers not covered and why. https://tickerinside.com/api/v1/batch?funds=VOO,QQQ,VTI
- `GET /screen?holds={holds}`: funds by `issuer`, `category`, `layer`, `expense_ratio_max`, `aum_min`, or `holds` (a stock) with `min_weight`; `sort`, `limit` and `offset`. CSV: /screen.csv. https://tickerinside.com/api/v1/screen?holds=NVDA&min_weight=10
- `GET /diversify?have={have}&try={try}`: each fund of `try` against those of `have` (QQQ:40 for a weight): overlap, correlations, mega-cap tech, sectors, countries, a sentence each. With `have` alone, the 30 large US ETFs of a published list ranked by weekly correlation with the portfolio, one per group first. Page: /diversify/. The list and its weekly returns: /diversify/candidates.json; one ETF's: /diversify/weekly/{ticker}.json. https://tickerinside.com/api/v1/diversify?have=QQQ,SMH&try=AVUV and https://tickerinside.com/api/v1/diversify?have=VOO
- `GET /history.json`: every fund with a holdings history, from its issuer's own files, with the dates of its oldest and newest files and the address of its history, under the history terms. https://tickerinside.com/api/v1/history.json
- `GET /history/{ticker}.json`: one fund's holdings history, each file date and what entered, exited and moved from one file to the next, weights only. https://tickerinside.com/api/v1/history/spy.json
- `GET /quarterly/{ticker}.json`: a fund's quarterly SEC reports since 2019; the funds in /quarterly.json. https://tickerinside.com/api/v1/quarterly/voo.json
- `GET /history/{ticker}/{date}.json`: every position of its latest report on or before the date. https://tickerinside.com/api/v1/history/voo/2020-03-31.json
- `GET /flows.json`: what the ETFs read daily from their issuers' files bought and sold on the latest complete market close, from their share counts: the largest net additions and reductions, index entries and exits, the last 20 closes; under the history terms. Every security moved: /api/v1/flows.csv. Feed: https://tickerinside.com/feeds/flows.xml. https://tickerinside.com/api/v1/flows.json
- `GET /flows/{ticker}.json`: one security's flows, funds adding and trimming, net change in shares and dollars, a 20-day series. Feeds: /feeds/stock/{ticker}.xml, and /feeds/fund/{ticker}.xml for a fund's changes. https://tickerinside.com/api/v1/flows/nvda.json
- `GET /status.json`: the nightly report, when the build ran and the date of each layer of the data. https://tickerinside.com/api/v1/status.json
- `GET /uptime.json`: live checks of the pages, the API and the MCP server, every five minutes. https://tickerinside.com/api/v1/uptime.json

Holders from SEC filings are in each stock file, under `holders_sec_nport`, and for a security with no stock file in its holders shard; they are not in `holders.json` or `securities.json`.

Each stock file carries its line of the ownership ledger under `etf_ownership`.

#### Errors and redirects

The HTTP status is the answer, and every answer under /api/ is open to any origin.

| Status | reason | Meaning | Next request |
|---|---|---|---|
| 200 |  | The file. | Read it. Every file carries its dates. |
| 204 |  | A browser's CORS preflight, an `OPTIONS` request, answered before any redirect: GET and HEAD from any origin, with the headers asked for, kept up to a day. | Nothing to do. |
| 301 |  | An upper case ticker, a share class written `BRK-B` or `BRK/B` (the file is `brk.b.json`), an address without `.json`, `/api/v1` alone, or punctuation copied from a sentence at its end. A key listed abroad with a hyphen, such as `SQM-B`, keeps it. A written comparison asked for in the other order leads to its file: `vym-vs-vig` to `vig-vs-vym.json`. A fund with no file under `/etf/` leads to its file under `/fund/`: `etf/voo.json` to `fund/voo.json`. `/stock/`, the name of the pages, leads to the stock files under `/sec/`: `stock/nvda.json` to `sec/nvda.json`. | Follow it (`curl -L`). `Location` gives the address. |
| 304 |  | Your `If-None-Match` matches the file's `ETag`. | Keep your copy. |
| 400 |  | A computed answer refused its query: `reason` (`missing_parameter`, `unknown_parameter`, `repeated_parameter`, `invalid_value`, `too_few_funds`, `too_many_funds`) and `parameter` say why. | Fix it as `message` says. |
| 400 | `too_large` | Past the limits of one call (fund files read, holdings compared or looked through): `limit` and `asked` give both figures. | Follow the address or tool `message` names first (`answered_by` gives them as fields), or ask for fewer funds per call. |
| 404 | `has_security_file` | The ticker asked for as a fund, under `/fund/` or `/etf/`, is not a covered fund, but it has a stock file or a holders-only answer. | `security`: that address. |
| 404 | `is_a_fund` | The ticker asked for as a stock is a covered fund. | `fund`: its holdings. `holders`: the shard that lists the funds holding it. |
| 404 | `not_held` | Under `/sec/`: no covered fund holds this key. A security they hold with no stock file answers 200 with `coverage` `holders_only`. An old key (`7203`) answers `earlier_key`, with `reads_as` from the `aliases` of its shard. | `holders`: the shard of its first character. `covered`: `securities.json`. |
| 404 | `not_in_directory` | Under `/fund/`: not covered, nor in the directory of US-listed funds; a listed one gets its `universe.json` code. | `covered`: `index.json`, which lists every covered fund. |
| 404 | `no_written_comparison` | Under `/compare/`: no comparison file for this pair, in either order. `pair` gives the two tickers asked for, and `written_comparisons` the pairs that have one, as `index.json` lists them. | `fund_files`: the fund files of the two, if covered. The overlap by weight is the sum, over the tickers both hold, of the smaller of the two weights. |
| 404 | `not_a_shard` | Under `/holders/`: not a shard. The shards are `a.json` to `z.json`, and `0.json` for a key that starts with any other character; `0.json` is also split by the key's first digit into `0/0.json` to `0/9.json`. | `holders`: the shard of the key's first character. |
| 404 | `not_in_archive` | The fund has no holdings history: only the funds read from issuer files have one. | `history`: `history.json`, which lists them. |
| 404 | `holdings_at_date_not_enabled` | Holdings at a date, `/history/{ticker}/{date}.json`, come from the fund's quarterly SEC reports, and this fund has none here (GLD; SPY and DIA, whose N-PORT carries no series): every valid date answers this. | `changes`: the fund's history file. |
| 404 | `invalid_date` | The date is not a calendar date written YYYY-MM-DD, or it is after today in UTC. | Ask again with a valid date. |
| 404 |  | Under `/overlap`, `/lookthrough` and `/diversify`: a fund the answer needs is not covered; `not_covered` lists the tickers and `reasons` their codes. | `covered`: `index.json`. |
| 405 |  | A computed answer asked with another method than GET or HEAD (`method_not_allowed`). | Use GET. |
| 404 | `not_held_by_daily_funds` | Under `/flows/`: no fund read daily from its issuer's files held the key or moved it in the window the flows cover. | `summary`: `flows.json`, the day's largest moves. |
| 503 |  | The file could not be served just then. The body's `error` is `unavailable`, with `Retry-After: 60`. | Retry after a minute. `uptime`: `uptime.json` says whether the site fails its own checks. |

Every 404 body is JSON. It holds `error`, always `not_covered`; `reason`, a code /contract/ lists; `ticker`, as asked for, or null when the address names no ticker; `message`; `docs`; and the follow-up address named above. Under /history/, it also holds `date` when a date was asked for. `before_history`, for a date before a fund's first file, is answered only once holdings at a date are served. A 400 body holds `error` (`bad_request`), `reason`, `message`, `docs`, and `parameter`, or `limit` and `asked`.


Every static file is served with an `ETag` and `Cache-Control: public, max-age=300, must-revalidate`; uptime.json is computed when asked and kept for one minute. The computed answers carry the same Cache-Control and an `ETag`, and the edge cache keeps each for up to a day. Every answer carries a `Link` header naming the OpenAPI description, this page and the status file.

#### CSV for spreadsheets

The fund files under /api/v1/fund/ and the stock files each have a CSV twin, written from the same JSON, with the date of the holdings on every row: /api/v1/fund/{ticker}.csv lists an ETF's holdings, heaviest first, with `holdings_kind` and `listed_pct` for a fund of the other layers, and /api/v1/sec/{ticker}.csv the covered funds that hold a stock. /api/v1/funds.csv lists every fund, one row each, with the address of its file, and /api/v1/securities.csv every security of securities.json. /overlap, /lookthrough and /screen have one too (.csv or format=csv): a row per pair, company or fund, with the dates. Google Sheets reads them with `IMPORTDATA`, Excel and Power BI from the web; https://tickerinside.com/spreadsheets/ has the formulas, the columns, six TI_ functions for Google Sheets in one Apps Script file, and four Power Query queries.

### Build with it

Five examples, each written in eleven languages, then three recipes for other jobs. This file shows each example in cURL, Python, the tickerinside client and JavaScript; the other languages are plain files, https://tickerinside.com/api/examples/{task}/{language}.{ext}. Each is shown with what it printed against the live API on the day it was recorded. The recipes' outputs are what they print on the files of 2026-10-12. Each example names your project in its User-Agent, which we ask of any program that calls the API on its own; it is a request, not a condition. CORS is open, so the JavaScript examples also run from a web page. The Python (tickerinside) examples use the client on PyPI, `pip install tickerinside`, version 0.5.0; it needs only the standard library, and with pandas installed every result also has a `.df` DataFrame.

Six use cases, each a page with a live example and tested code, all in https://tickerinside.com/api/sections/use-cases.md:

```sh
# ETF holdings
curl -s https://tickerinside.com/api/v1/fund/voo.json
# ETF overlap
curl -s "https://tickerinside.com/api/v1/overlap?funds=VOO,QQQ"
# Which ETFs hold a stock
curl -s https://tickerinside.com/api/v1/sec/nvda.json
# ETF holdings history
curl -s https://tickerinside.com/api/v1/history/spy.json
# Portfolio exposure
curl -s "https://tickerinside.com/api/v1/lookthrough?portfolio=VOO:60,QQQ:40&top=5"
# ETF screener
curl -s "https://tickerinside.com/api/v1/screen?holds=NVDA&min_weight=10&expense_ratio_max=0.4&limit=5"
```

#### One fund's holdings, largest first

`GET /api/v1/fund/voo.json`. It prints the date of the issuer's file, its holdings as ticker and weight in percent, largest first, and the cite_as line. It reads `holdings`, `holdings_as_of` and `cite_as`.

What the Python example printed, recorded 2026-09-28 from the live API:

```text
VOO holdings_as_of 2026-08-31
503 holdings, largest first
NVDA 8.0927
AAPL 7.0432
MSFT 5.7033
AMZN 3.8487
GOOGL 3.0115
[trimmed: 498 more lines]
TickerInside, Vanguard S&P 500 ETF (VOO), holdings from the issuer's file of 2026-08-31, https://tickerinside.com/etf/voo/, CC BY 4.0
```

##### cURL

Needs curl, and jq 1.6 or later for the JSON. Install: jq: brew install jq, or apt install jq. Save as holdings.sh, then run: bash holdings.sh, or paste into a terminal.

```sh
curl -fsS -A "MyProject/1.0 (+https://example.com)" \
  https://tickerinside.com/api/v1/fund/voo.json |
jq -r '
  # The date of the issuer file the weights come from
  "VOO holdings_as_of \(.holdings_as_of)",
  # holdings maps each ticker to its weight in percent: largest first
  "\(.holdings | length) holdings, largest first",
  (.holdings | to_entries | sort_by(-.value)[] | "\(.key) \(.value)"),
  # The line to print under any figure you quote
  .cite_as'
```

It printed the same lines as the Python example, recorded 2026-09-29 from the live API.

##### Python

Needs Python 3.9 or later and requests. Install: pip install requests. Save as holdings.py, then run: python holdings.py.

```python
import requests

# Name your own project in the User-Agent
HEADERS = {"User-Agent": "MyProject/1.0 (+https://example.com)"}

# Read VOO's file: one GET, no key
r = requests.get("https://tickerinside.com/api/v1/fund/voo.json",
                 headers=HEADERS, timeout=30)
r.raise_for_status()
fund = r.json()

# The date of the issuer's file the weights come from
print("VOO holdings_as_of", fund["holdings_as_of"])

# holdings maps each ticker to its weight in percent: sort it, largest first
rows = sorted(fund["holdings"].items(), key=lambda kv: kv[1], reverse=True)
print(len(rows), "holdings, largest first")
for ticker, weight in rows:
    print(ticker, weight)

# The line to print under any figure you quote
print(fund["cite_as"])
```

##### Python (tickerinside)

Needs Python 3.9 or later and the tickerinside package, standard library only. Install: pip install tickerinside. The client sends its own User-Agent: tickerinside-python and its version. Save as holdings.py, then run: python holdings.py.

```python
import tickerinside as ti

# One call reads VOO's file (the client names itself in its User-Agent)
voo = ti.holdings("VOO")

# The date of the issuer's file the weights come from
print("VOO holdings_as_of", voo.holdings_as_of)

# data lists the holdings as {"ticker", "weight_pct"}, largest first
print(len(voo.data), "holdings, largest first")
for row in voo.data:
    print(row["ticker"], row["weight_pct"])

# The line to print under any figure you quote
print(voo.cite)
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

##### JavaScript

Needs Node.js 20 or later, or a browser inside <script type="module">. A browser may send its own User-Agent instead of the one set here. Save as holdings.mjs, then run: node holdings.mjs.

```js
// Name your own project (a browser may send its own User-Agent instead)
const headers = { "User-Agent": "MyProject/1.0 (+https://example.com)" };

// Read VOO's file: one GET, no key
const res = await fetch("https://tickerinside.com/api/v1/fund/voo.json",
  { headers });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const fund = await res.json();

// The date of the issuer's file the weights come from
console.log(`VOO holdings_as_of ${fund.holdings_as_of}`);

// holdings maps each ticker to its weight in percent: sort it, largest first
const rows = Object.entries(fund.holdings).sort((a, b) => b[1] - a[1]);
console.log(`${rows.length} holdings, largest first`);
for (const [ticker, weight] of rows) console.log(`${ticker} ${weight}`);

// The line to print under any figure you quote
console.log(fund.cite_as);
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

The same example in the other languages, each with what it needs and the command that runs it: https://tickerinside.com/api/sections/build.md

#### Which ETFs hold a stock, and at what weight

`GET /api/v1/sec/nvda.json`. It prints how many funds hold it, then every fund from the issuers' files as fund, weight in percent and the date of that fund's file, in the file's order (largest weight first), and the cite_as line. It reads `held_by`, `held_by_sec_nport`, `holders` and `cite_as`.

For every security at once, load /api/v1/holders.json (5.3 MB) once and keep it; it covers the 690 issuer files.

What the Python example printed, recorded 2026-09-28 from the live API:

```text
NVDA held_by 178 (issuer files), held_by_sec_nport 506 (SEC filings)
GXPT 19.77 2026-09-25
VGT 17.7869 2026-08-31
VUSG 16.9756 2026-09-28
IYW 16.69 2026-09-25
TOPT 16.09 2026-09-25
[trimmed: 173 more lines]
TickerInside, Nvidia (NVDA), holders from each covered fund's own file and from SEC Form N-PORT filings, each dated, prices through 2026-09-25, https://tickerinside.com/stock/nvda/, CC BY 4.0
```

##### cURL

Needs curl, and jq 1.6 or later for the JSON. Install: jq: brew install jq, or apt install jq. Save as holders.sh, then run: bash holders.sh, or paste into a terminal.

```sh
curl -fsS -A "MyProject/1.0 (+https://example.com)" \
  https://tickerinside.com/api/v1/sec/nvda.json |
jq -r '
  # How many funds hold it: from issuer files, and from SEC filings
  "NVDA held_by \(.held_by) (issuer files), "
    + "held_by_sec_nport \(.held_by_sec_nport) (SEC filings)",
  # holders is sorted, largest weight first: [fund, weight %, file date]
  (.holders[] | "\(.[0]) \(.[1]) \(.[2])"),
  # The line to print under any figure you quote
  .cite_as'
```

What it printed, recorded 2026-09-29 from the live API:

```text
NVDA held_by 178 (issuer files), held_by_sec_nport 506 (SEC filings)
GXPT 19.77 2026-09-25
VGT 17.7869 2026-08-31
VUSG 16.9756 2026-09-28
IYW 16.69 2026-09-25
TOPT 16.09 2026-09-25
[trimmed: 173 more lines]
TickerInside, Nvidia (NVDA), holders from each covered fund's own file and from SEC Form N-PORT filings, each dated, prices through 2026-09-28, https://tickerinside.com/stock/nvda/, CC BY 4.0
```

##### Python

Needs Python 3.9 or later and requests. Install: pip install requests. Save as holders.py, then run: python holders.py.

```python
import requests

# Name your own project in the User-Agent
HEADERS = {"User-Agent": "MyProject/1.0 (+https://example.com)"}

# Read NVDA's file: one GET, no key
r = requests.get("https://tickerinside.com/api/v1/sec/nvda.json",
                 headers=HEADERS, timeout=30)
r.raise_for_status()
stock = r.json()

# How many funds hold it: in their issuers' own files, and in SEC filings
print("NVDA held_by", stock["held_by"], "(issuer files), held_by_sec_nport",
      stock["held_by_sec_nport"], "(SEC filings)")

# holders is sorted, largest weight first: [fund, weight %, file date]
for fund, weight, file_date in stock["holders"]:
    print(fund, weight, file_date)

# The line to print under any figure you quote
print(stock["cite_as"])
```

##### Python (tickerinside)

Needs Python 3.9 or later and the tickerinside package, standard library only. Install: pip install tickerinside. The client sends its own User-Agent: tickerinside-python and its version. Save as holders.py, then run: python holders.py.

```python
import tickerinside as ti

# The funds that hold NVDA (reads its file and the list of funds)
nvda = ti.holders("NVDA")

# How many funds hold it: in their issuers' own files, and in SEC filings
n = nvda.data["counts"]
print("NVDA held_by", n["issuer"], "(issuer files), held_by_sec_nport",
      n["sec_nport"], "(SEC filings)")

# data["issuer"] is sorted, largest weight first, each with its file date
for row in nvda.data["issuer"]:
    print(row["fund"], row["weight_pct"], row["holdings_as_of"])

# The line to print under any figure you quote
print(nvda.cite)
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

##### JavaScript

Needs Node.js 20 or later, or a browser inside <script type="module">. A browser may send its own User-Agent instead of the one set here. Save as holders.mjs, then run: node holders.mjs.

```js
// Name your own project (a browser may send its own User-Agent instead)
const headers = { "User-Agent": "MyProject/1.0 (+https://example.com)" };

// Read NVDA's file: one GET, no key
const res = await fetch("https://tickerinside.com/api/v1/sec/nvda.json",
  { headers });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const stock = await res.json();

// How many funds hold it: in their issuers' own files, and in SEC filings
console.log(`NVDA held_by ${stock.held_by} (issuer files), ` +
  `held_by_sec_nport ${stock.held_by_sec_nport} (SEC filings)`);

// holders is sorted, largest weight first: [fund, weight %, file date]
for (const [fund, weight, date] of stock.holders) {
  console.log(`${fund} ${weight} ${date}`);
}

// The line to print under any figure you quote
console.log(stock.cite_as);
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

The same example in the other languages, each with what it needs and the command that runs it: https://tickerinside.com/api/sections/build.md

#### The overlap of two funds, by weight

`GET /api/v1/fund/voo.json` and `GET /api/v1/fund/qqq.json`. It prints the date of each fund's file, the overlap by weight with the count of companies in both, and each file's cite_as line. The overlap by weight is the site's definition: the sum, over the companies both hold, of the smaller of the two weights, the figure of /api/v1/compare/voo-vs-qqq.json. It reads `holdings`, `holdings_as_of` and `cite_as`. Both funds come from issuer files. With a fund from SEC filings, the site also sets apart the tickers its abroad list names when the other fund holds the US company of that ticker; the Python client's compare() applies that rule.

Any pair, whatever its size, from the two fund files; /overlap computes the same on the server. This is the `by_weight` figure of the comparison files: the smaller of the two weights of every ticker both funds hold, summed. Quote both file dates with it.

What the Python example printed, recorded 2026-09-28 from the live API:

```text
VOO holdings_as_of 2026-08-31
QQQ holdings_as_of 2026-09-26
overlap by weight 54.0%, 86 companies in both
TickerInside, Vanguard S&P 500 ETF (VOO), holdings from the issuer's file of 2026-08-31, https://tickerinside.com/etf/voo/, CC BY 4.0
TickerInside, Invesco QQQ Trust (QQQ), holdings from the issuer's file of 2026-09-26, https://tickerinside.com/etf/qqq/, CC BY 4.0
```

##### cURL

Needs curl, and jq 1.6 or later for the JSON. Install: jq: brew install jq, or apt install jq. Save as overlap.sh, then run: bash overlap.sh, or paste into a terminal.

```sh
UA="MyProject/1.0 (+https://example.com)"
{ curl -fsS -A "$UA" https://tickerinside.com/api/v1/fund/voo.json
  curl -fsS -A "$UA" https://tickerinside.com/api/v1/fund/qqq.json; } |
jq -rs '
  # -s reads the two answers as one list, so no file is written
  .[0] as $voo | .[1] as $qqq
  # For every ticker both funds hold, the smaller of its two weights
  | [$voo.holdings | to_entries[] | select($qqq.holdings[.key] != null)
     | [.value, $qqq.holdings[.key]] | min] as $m
  # Overlap by weight, as the site computes it: those weights, added up,
  # in tenths of a percent, printed with one decimal (54.0, not 54)
  | ($m | add * 10 | round) as $tenths
  # Each fund has the date of its own issuer file
  | "VOO holdings_as_of \($voo.holdings_as_of)",
    "QQQ holdings_as_of \($qqq.holdings_as_of)",
    "overlap by weight \($tenths / 10 | floor).\($tenths % 10)%, "
      + "\($m | length) companies in both",
  # The lines to print under the figure, one per fund file
    $voo.cite_as, $qqq.cite_as'
```

It printed the same lines as the Python example, recorded 2026-09-29 from the live API.

##### Python

Needs Python 3.9 or later and requests. Install: pip install requests. Save as overlap.py, then run: python overlap.py.

```python
import requests

# Name your own project in the User-Agent
HEADERS = {"User-Agent": "MyProject/1.0 (+https://example.com)"}

# Read both funds' files; each has the date of its own issuer's file
funds = {}
for ticker in ("VOO", "QQQ"):
    url = f"https://tickerinside.com/api/v1/fund/{ticker.lower()}.json"
    r = requests.get(url, headers=HEADERS, timeout=30)
    r.raise_for_status()
    funds[ticker] = r.json()
    print(ticker, "holdings_as_of", funds[ticker]["holdings_as_of"])

# Overlap by weight, as the site computes it: for every ticker both funds
# hold, add the smaller of its two weights
a, b = funds["VOO"]["holdings"], funds["QQQ"]["holdings"]
shared = [t for t in a if t in b]
overlap = sum(min(a[t], b[t]) for t in shared)
print(f"overlap by weight {overlap:.1f}%, {len(shared)} companies in both")

# The lines to print under the figure, one per fund file
for fund in funds.values():
    print(fund["cite_as"])
```

##### Python (tickerinside)

Needs Python 3.9 or later and the tickerinside package, standard library only. Install: pip install tickerinside. The client sends its own User-Agent: tickerinside-python and its version. Save as overlap.py, then run: python overlap.py.

```python
import tickerinside as ti

# Reads both funds' files and measures the overlap as the site does
c = ti.compare("VOO", "QQQ")

# Each fund's holdings come with the date of its own issuer's file
for ticker, day in c.holdings_as_of.items():
    print(ticker, "holdings_as_of", day)

# by_weight: for every ticker both funds hold, the smaller weight, added up.
# companies_in_both is the field a /compare/ file calls overlap.n_shared
ov = c.data["overlap"]
print(f"overlap by weight {ov['by_weight']}%, "
      f"{ov['companies_in_both']} companies in both")

# The line to print under the figure
print(c.cite)
```

What it printed, recorded 2026-09-28 from the live API:

```text
VOO holdings_as_of 2026-08-31
QQQ holdings_as_of 2026-09-26
overlap by weight 54.0%, 86 companies in both
TickerInside, VOO vs QQQ, holdings files of 2026-08-31 and 2026-09-26, https://tickerinside.com/compare/voo-vs-qqq/, CC BY 4.0
```

##### JavaScript

Needs Node.js 20 or later, or a browser inside <script type="module">. A browser may send its own User-Agent instead of the one set here. Save as overlap.mjs, then run: node overlap.mjs.

```js
// Name your own project (a browser may send its own User-Agent instead)
const headers = { "User-Agent": "MyProject/1.0 (+https://example.com)" };
const API = "https://tickerinside.com/api/v1";

// Read both funds' files; each has the date of its own issuer's file
const funds = {};
for (const ticker of ["VOO", "QQQ"]) {
  const url = `${API}/fund/${ticker.toLowerCase()}.json`;
  const res = await fetch(url, { headers });
  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
  funds[ticker] = await res.json();
  console.log(`${ticker} holdings_as_of ${funds[ticker].holdings_as_of}`);
}

// Overlap by weight, as the site computes it: for every ticker both funds
// hold, add the smaller of its two weights
const a = funds.VOO.holdings, b = funds.QQQ.holdings;
const shared = Object.keys(a).filter((t) => Object.hasOwn(b, t));
const overlap = shared.reduce((sum, t) => sum + Math.min(a[t], b[t]), 0);
console.log(`overlap by weight ${overlap.toFixed(1)}%, ` +
  `${shared.length} companies in both`);

// The lines to print under the figure, one per fund file
for (const fund of Object.values(funds)) console.log(fund.cite_as);
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

The same example in the other languages, each with what it needs and the command that runs it: https://tickerinside.com/api/sections/build.md

#### How much of a company US ETFs hold

`GET /api/v1/sec/nvda.json`. It prints the lower bound in percent and its basis, the shares counted against the shares outstanding and the date of that count, the oldest and newest holdings file behind it, and the cite_as line. When no figure is published, it prints the refused code. It reads `etf_ownership.pct_lower_bound`, `etf_ownership.basis`, `etf_ownership.refused`, `etf_ownership.shares_held`, `etf_ownership.shares_outstanding`, `etf_ownership.shares_outstanding_as_of`, `etf_ownership.holdings_dates` and `etf_ownership.cite_as`.

What the Python example printed, recorded 2026-09-28 from the live API:

```text
NVDA etf_ownership: at least 11.2% of its shares held by covered US ETFs, basis company
shares_held 2,701,201,789 shares_outstanding 24,100,000,000 as of 2026-08-21
holdings dated 2026-01-31 to 2026-09-28
TickerInside, Nvidia (NVDA), at least 11.2% of its shares outstanding held by 679 covered US ETFs (ti-ownership/1), holdings dated 2026-01-31 to 2026-09-28, shares outstanding as of 2026-08-21 from SEC filings, https://tickerinside.com/api/v1/sec/nvda.json, CC BY 4.0
```

##### cURL

Needs curl, and jq 1.6 or later for the JSON. Install: jq: brew install jq, or apt install jq. Save as ownership.sh, then run: bash ownership.sh, or paste into a terminal.

```sh
curl -fsS -A "MyProject/1.0 (+https://example.com)" \
  https://tickerinside.com/api/v1/sec/nvda.json |
jq -r '
  # A whole number with a comma every three digits
  def commas: tostring
    | if length > 3 then (.[:-3] | commas) + "," + .[-3:] else . end;
  # The etf_ownership block holds the figure
  .etf_ownership
  # pct_lower_bound is null when no figure is published; refused says why
  | if .pct_lower_bound == null then
      "NVDA etf_ownership: no figure published, refused \(.refused)"
    else
      "NVDA etf_ownership: at least \(.pct_lower_bound)% of its shares"
        + " held by covered US ETFs, basis \(.basis)",
      # The shares counted, and the date of the count of shares outstanding
      "shares_held \(.shares_held | commas) shares_outstanding"
        + " \(.shares_outstanding | commas)"
        + " as of \(.shares_outstanding_as_of)",
      # The oldest and the newest holdings file behind the figure
      "holdings dated \(.holdings_dates.oldest) to \(.holdings_dates.newest)",
      # The line to print under the figure
      .cite_as
    end'
```

It printed the same lines as the Python example, recorded 2026-09-29 from the live API.

##### Python

Needs Python 3.9 or later and requests. Install: pip install requests. Save as ownership.py, then run: python ownership.py.

```python
import requests

# Name your own project in the User-Agent
HEADERS = {"User-Agent": "MyProject/1.0 (+https://example.com)"}

# Read NVDA's file: one GET, no key. The etf_ownership block holds the figure
r = requests.get("https://tickerinside.com/api/v1/sec/nvda.json",
                 headers=HEADERS, timeout=30)
r.raise_for_status()
own = r.json()["etf_ownership"]

# pct_lower_bound is null when no figure is published, and refused says why
if own["pct_lower_bound"] is None:
    print("NVDA etf_ownership: no figure published, refused", own["refused"])
else:
    print(f"NVDA etf_ownership: at least {own['pct_lower_bound']}% of its "
          f"shares held by covered US ETFs, basis {own['basis']}")
    # The shares counted, and the date of the count of shares outstanding
    print(f"shares_held {own['shares_held']:,} "
          f"shares_outstanding {own['shares_outstanding']:,} "
          f"as of {own['shares_outstanding_as_of']}")
    # The oldest and the newest holdings file behind the figure
    dates = own["holdings_dates"]
    print("holdings dated", dates["oldest"], "to", dates["newest"])
    # The line to print under the figure
    print(own["cite_as"])
```

##### Python (tickerinside)

Needs Python 3.9 or later and the tickerinside package, standard library only. Install: pip install tickerinside. The client sends its own User-Agent: tickerinside-python and its version. Save as ownership.py, then run: python ownership.py.

```python
import tickerinside as ti

# NVDA's file, as served; the etf_ownership block holds the figure
own = ti.security("NVDA").data["etf_ownership"]

# pct_lower_bound is null when no figure is published, and refused says why
if own["pct_lower_bound"] is None:
    print("NVDA etf_ownership: no figure published, refused", own["refused"])
else:
    print(f"NVDA etf_ownership: at least {own['pct_lower_bound']}% of its "
          f"shares held by covered US ETFs, basis {own['basis']}")
    # The shares counted, and the date of the count of shares outstanding
    print(f"shares_held {own['shares_held']:,} "
          f"shares_outstanding {own['shares_outstanding']:,} "
          f"as of {own['shares_outstanding_as_of']}")
    # The oldest and the newest holdings file behind the figure
    dates = own["holdings_dates"]
    print("holdings dated", dates["oldest"], "to", dates["newest"])
    # The line to print under the figure
    print(own["cite_as"])
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

##### JavaScript

Needs Node.js 20 or later, or a browser inside <script type="module">. A browser may send its own User-Agent instead of the one set here. Save as ownership.mjs, then run: node ownership.mjs.

```js
// Name your own project (a browser may send its own User-Agent instead)
const headers = { "User-Agent": "MyProject/1.0 (+https://example.com)" };

// Read NVDA's file: one GET, no key. The etf_ownership block holds the figure
const res = await fetch("https://tickerinside.com/api/v1/sec/nvda.json",
  { headers });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const own = (await res.json()).etf_ownership;

// pct_lower_bound is null when no figure is published, and refused says why
if (own.pct_lower_bound === null) {
  console.log("NVDA etf_ownership: no figure published, refused",
    own.refused);
} else {
  console.log(`NVDA etf_ownership: at least ${own.pct_lower_bound}% of its ` +
    `shares held by covered US ETFs, basis ${own.basis}`);
  // The shares counted, and the date of the count of shares outstanding
  // toLocaleString("en-US") puts a comma every three digits
  console.log(`shares_held ${own.shares_held.toLocaleString("en-US")} ` +
    `shares_outstanding ${own.shares_outstanding.toLocaleString("en-US")} ` +
    `as of ${own.shares_outstanding_as_of}`);
  // The oldest and the newest holdings file behind the figure
  const dates = own.holdings_dates;
  console.log(`holdings dated ${dates.oldest} to ${dates.newest}`);
  // The line to print under the figure
  console.log(own.cite_as);
}
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

The same example in the other languages, each with what it needs and the command that runs it: https://tickerinside.com/api/sections/build.md

#### Every covered fund, with its name

`GET /api/v1/funds.json`. It prints how many funds are read from issuer files and the date of the data, how many more come from SEC filings (listed in sec_funds), then every issuer fund as ticker and name. It reads `count`, `as_of`, `sec_count`, `funds[].t` and `funds[].n`.

What the Python example printed, recorded 2026-09-28 from the live API:

```text
685 funds from issuer files, as_of 2026-09-25
1764 more from SEC filings, listed in sec_funds
AAXJ iShares MSCI All Country Asia ex Japan ETF
ACWI iShares MSCI ACWI ETF
ACWV iShares MSCI Global Min Vol Factor ETF
ACWX iShares MSCI ACWI ex U.S. ETF
AGNG Global X Aging Population ETF
[trimmed: 679 more lines]
ZAP Global X U.S. Electrification ETF
```

##### cURL

Needs curl, and jq 1.6 or later for the JSON. Install: jq: brew install jq, or apt install jq. Save as funds.sh, then run: bash funds.sh, or paste into a terminal.

```sh
curl -fsS -A "MyProject/1.0 (+https://example.com)" \
  https://tickerinside.com/api/v1/funds.json |
jq -r '
  # funds: read from issuer files, with the date of the data
  "\(.count) funds from issuer files, as_of \(.as_of)",
  # sec_funds: more US stock ETFs, from SEC filings, t and n as in funds
  "\(.sec_count) more from SEC filings, listed in sec_funds",
  # One entry per fund: t is the ticker, n the name
  (.funds[] | "\(.t) \(.n)")'
```

What it printed, recorded 2026-09-29 from the live API:

```text
693 funds from issuer files, as_of 2026-09-28
1756 more from SEC filings, listed in sec_funds
AAXJ iShares MSCI All Country Asia ex Japan ETF
ACWI iShares MSCI ACWI ETF
ACWV iShares MSCI Global Min Vol Factor ETF
ACWX iShares MSCI ACWI ex U.S. ETF
AGNG Global X Aging Population ETF
[trimmed: 687 more lines]
ZAP Global X U.S. Electrification ETF
```

##### Python

Needs Python 3.9 or later and requests. Install: pip install requests. Save as funds.py, then run: python funds.py.

```python
import requests

# Name your own project in the User-Agent
HEADERS = {"User-Agent": "MyProject/1.0 (+https://example.com)"}

# Read the list of covered funds: one GET, no key, one file for all of them
r = requests.get("https://tickerinside.com/api/v1/funds.json",
                 headers=HEADERS, timeout=30)
r.raise_for_status()
doc = r.json()

# funds: read from their issuers' own files, with the date of the data
print(doc["count"], "funds from issuer files, as_of", doc["as_of"])
# sec_funds: more US stock ETFs, from SEC filings, t and n as in funds
print(doc["sec_count"], "more from SEC filings, listed in sec_funds")

# One entry per fund: t is the ticker, n the name
for f in doc["funds"]:
    print(f["t"], f["n"])
```

##### Python (tickerinside)

Needs Python 3.9 or later and the tickerinside package, standard library only. Install: pip install tickerinside. The client sends its own User-Agent: tickerinside-python and its version. Save as funds.py, then run: python funds.py.

```python
import tickerinside as ti

# Every covered fund, one row each, sorted by ticker
funds = ti.funds()

# layer says where the holdings come from: "issuer" or "sec_nport"
issuer = [f for f in funds.data if f["layer"] == "issuer"]
print(len(issuer), "funds from issuer files, as_of", funds.as_of)
print(len(funds.data) - len(issuer), "more from SEC filings, layer sec_nport")

# One row per fund read from its issuer's own file
for f in issuer:
    print(f["ticker"], f["name"])

# The line to print under the list
print(funds.cite)
```

What it printed, recorded 2026-09-28 from the live API:

```text
685 funds from issuer files, as_of 2026-09-25
1764 more from SEC filings, layer sec_nport
AAXJ iShares MSCI All Country Asia ex Japan ETF
ACWI iShares MSCI ACWI ETF
ACWV iShares MSCI Global Min Vol Factor ETF
ACWX iShares MSCI ACWI ex U.S. ETF
AGNG Global X Aging Population ETF
[trimmed: 680 more lines]
TickerInside, US ETFs covered, 685 funds from the issuers' own files and 1764 from SEC Form N-PORT filings, as of 2026-09-25, https://tickerinside.com/api/v1/funds.json, CC BY 4.0
```

##### JavaScript

Needs Node.js 20 or later, or a browser inside <script type="module">. A browser may send its own User-Agent instead of the one set here. Save as funds.mjs, then run: node funds.mjs.

```js
// Name your own project (a browser may send its own User-Agent instead)
const headers = { "User-Agent": "MyProject/1.0 (+https://example.com)" };

// Read the list of covered funds: one GET, no key, one file for all of them
const res = await fetch("https://tickerinside.com/api/v1/funds.json",
  { headers });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const doc = await res.json();

// funds: read from their issuers' own files, with the date of the data
console.log(`${doc.count} funds from issuer files, as_of ${doc.as_of}`);
// sec_funds: more US stock ETFs, from SEC filings, t and n as in funds
console.log(`${doc.sec_count} more from SEC filings, listed in sec_funds`);

// One entry per fund: t is the ticker, n the name
for (const f of doc.funds) console.log(`${f.t} ${f.n}`);
```

It printed the same lines as the Python example, recorded 2026-09-28 from the live API.

The same example in the other languages, each with what it needs and the command that runs it: https://tickerinside.com/api/sections/build.md

#### Recipes for other jobs

Each output shown under a recipe is what it prints on the files of 2026-10-12. The Python recipes share this helper. It sends a User-Agent that names your project, which we ask of any program that calls the API on its own; it is a request, not a condition.

```python
import json
import urllib.request

API = "https://tickerinside.com/api/v1/"
UA = {"User-Agent": "MyProject/1.0 (+https://example.com)"}


def get(path):
    """One file of the TickerInside API, as Python objects."""
    req = urllib.request.Request(API + path, headers=UA)
    with urllib.request.urlopen(req) as r:
        return json.load(r)
```

##### An ETF's full holdings as CSV (pandas)

One row per holding, heaviest first, written to a file you can open in any spreadsheet.

```python
import pandas as pd

f = get("fund/schd.json")
df = (pd.Series(f["holdings"], name="weight_pct")
        .rename_axis("ticker").reset_index()
        .sort_values("weight_pct", ascending=False))
df.to_csv("schd_holdings.csv", index=False)
print(len(df), "rows, holdings as of", f["holdings_as_of"])
print(df.head(3).to_string(index=False))
```

```text
99 rows, holdings as of 2026-05-31
ticker  weight_pct
  QCOM      6.7377
   TXN      5.9047
   UNH      5.0926
```

##### Correlation between funds (numpy)

Every fund and stock file with a weekly series carries the same 156 weeks, ending at the same date, `weeks_end`, so the series line up without any date matching.

```python
import numpy as np

tickers = ["voo", "qqq", "schd", "vgt"]
rows = [get(f"fund/{t}.json")["weekly"] for t in tickers]
R = np.array(rows, dtype=float)    # a null week becomes nan
print(np.corrcoef(R).round(2))
```

```text
[[1.   0.95 0.58 0.92]
 [0.95 1.   0.37 0.97]
 [0.58 0.37 1.   0.35]
 [0.92 0.97 0.35 1.  ]]
```

The rows and columns are VOO, QQQ, SCHD and VGT. A week without a return is null, which `dtype=float` turns into nan, and `np.corrcoef` then gives nan for that fund: keep the weeks every fund has, or use pandas, whose `corr` skips them pair by pair. With fewer than 110 weekly returns, `weekly` is an empty list, or null in a file from SEC filings: leave that fund out.

##### Files to disk from a shell (curl)

Any file can be saved as it is. The `-L` follows the 301 that an upper case ticker gets, which matters when a path is built from user input.

```sh
# One fund: its holdings with their weights, and the date of its file
curl -sL https://tickerinside.com/api/v1/fund/voo.json -o voo.json

# One stock: which ETFs hold it, heaviest first
curl -sL https://tickerinside.com/api/v1/sec/nvda.json -o nvda.json

# What exists, and the date of the data
curl -sL https://tickerinside.com/api/v1/index.json -o index.json
```

### Connect an assistant over MCP

Server URL: https://tickerinside.com/mcp (streamable HTTP, no authentication, twelve read-only tools). In Claude, connect it from Claude's connector directory (https://claude.ai/directory/tickerinside) or add it as a custom connector. In Claude Code:

```sh
claude mcp add --transport http tickerinside https://tickerinside.com/mcp
```

Local servers only: `npx -y tickerinside-mcp@latest`.

Tools: `list_etfs` (Coverage and ETF search), `get_etf_holdings` (ETF holdings and profile), `compare_etfs` (Overlap and risk of two ETFs), `get_etf_overlap_matrix` (Overlap across many ETFs), `get_etf_portfolio_lookthrough` (Companies inside a portfolio), `get_etf_portfolio_risk` (Portfolio risk breakdown), `find_etfs_holding_stock` (ETFs that hold a stock), `compare_stocks` (Stock comparison and weight in an ETF), `get_etf_ownership` (ETF ownership of a stock), `get_etf_holdings_history` (ETF holdings history), `get_etf_holdings_changes` (ETF holdings changes), `get_etf_flows` (ETF buying and selling).

### Where the data comes from

- Issuers' own holdings files: 688 funds from five issuers, read every weekday night; `source_layer` is `issuer` and `holdings_as_of` is the date of the file. iShares 289, newest file 2026-10-12. Invesco 153, newest file 2026-10-12. State Street SPDR 92, newest file 2026-10-12. Global X 89, newest file 2026-10-12. Vanguard 67, newest file 2026-10-13. Some funds of these issuers are served from their SEC filings instead, under `sec_funds` in funds.json: 20 State Street SPDR (GNR, RWR), 13 iShares (IVVM, MAXJ), 9 Global X (PFFD, RYLD), 6 Invesco (PCEF, PBP).
- SEC Form N-PORT filings: 1,944 other US stock ETFs, from the latest filing each one makes; `source_layer` is `sec_nport` and `report_date` is the quarter end the filing describes (2026-01-31 to 2026-08-31), usually two to four months before it is read. What cannot be keyed to a ticker is left out and counted in `unmapped_pct`.
- Fixed income funds (922, `sec_nport_bonds`) and multi-asset funds (235, `sec_nport_multi_asset`), from the same filings.
- Derivative-based funds (1,363, `sec_nport_derivatives`, from the same filings) and trusts and commodity pools (131, `trust_filings`, from their own SEC filings).
- Prices: end of day prices through 2026-10-12, giving weekly total returns over the same 156 weeks. A fund or stock with fewer than 110 of them has no series and no figure over three or five years, and a week without a return is null.

The ETF ownership ledger: for each stock with a file, `etf_ownership` gives the share of the company's shares outstanding that the covered US ETFs hold, as a lower bound, at least this percent from this many funds. The shares held are the share counts of the issuer files, and for the other funds the share balances of their latest SEC filings. A Vanguard ETF's shares are counted for its ETF share class alone. A fund is counted once, and a fund's shares of another covered fund are counted in that fund. The shares outstanding are the most recent count on the cover of a periodic report the company filed with the SEC: a 10-K, 10-Q, 20-F or 40-F, amendments included. They come from the SEC's XBRL data and are published with their date and filing. The count is every class rolled up to the company; or, when the filing itself is read, the one count its cover gives; or the class's own count when only the class checks out.

A figure is published only when all three of these hold:

- The SEC's count is at most 2% below an independent current count of the same shares, since a lower count would put the percent too high. It is at most 25% above it for a company with one class, or 5% above it when several classes are rolled up.
- No split falls between the holdings dates and the date of the count.
- The figure comes to at most 100%.

So a figure can be too high by about 2% of itself, at most. A row that is another security under the stock's ticker is not counted: a preferred share, a foreign company's local code, or a value per share far from the stock's close on the row's date. A file that gives no market values is checked the same way, from its weights and the fund's stated net assets. A single issuer file's count is never published alone. Funds outside the coverage, and covered funds whose count could not be used, are not in it. Method, formula and test vectors: https://tickerinside.com/api/v1/methods.json (`ti-ownership/1`).

#### Two dates in every fund file

Holdings refresh when the issuer publishes a new file, daily for some funds and monthly for others, so a fund file carries two dates. `as_of` is the price date, behind every return and risk figure. `holdings_as_of` is the date of the holdings file: often weeks older than `as_of`, and sometimes later, since some issuers date a file with the next business day (ESGV's file of 2026-10-13, a Tuesday). In a comparison and in holders.json, `holdings_as_of` is a map keyed by fund; in a stock file, each holder row carries its fund's file date. In ownership.json, `as_of` is the newest holdings date counted, and in history.json the newest archived file date. Quote both dates: an overlap figure without its holdings date cannot be checked.

#### How fresh the holdings are, by source

Measured on the fund files of this build: funds, median age of their holdings in days, share dated within 7 and within 35 days.

| Source | Funds | Median age, days | Within 7 days | Within 35 days |
|---|---:|---:|---:|---:|
| Issuers' own files, read every weekday night | 690 | 1 | 92.0% | 92.3% |
| iShares | 289 | 1 | 99.3% | 100.0% |
| Invesco | 153 | 1 | 100.0% | 100.0% |
| State Street SPDR | 92 | 1 | 100.0% | 100.0% |
| Global X | 89 | 1 | 100.0% | 100.0% |
| Vanguard | 67 | 43 | 20.9% | 20.9% |
| Sponsors' websites, read every weekday night | 140 | 1 | 91.4% | 100.0% |
| SEC filings (Form N-PORT), stock ETFs | 1,982 | 105 | 0.0% | 0.0% |
| SEC filings (Form N-PORT), fixed income ETFs | 924 | 105 | 0.0% | 0.0% |
| SEC filings (Form N-PORT), multi-asset ETFs | 250 | 105 | 0.0% | 0.0% |
| SEC filings (Form N-PORT), derivative-based ETFs | 1,398 | 74 | 0.0% | 0.0% |
| Trusts' own reports (10-Q, 10-K and the like) | 131 | 105 | 0.0% | 1.5% |
| Prospectus only, until the first holdings filing | 282 | no holdings yet |  |  |


#### How holdings are keyed

- A fund or a stock is keyed by its ticker, upper case in the files and lower case in the path (/api/v1/fund/voo.json). A share class keeps its dot: `BRK.B`, at /api/v1/sec/brk.b.json.
- A line listed outside the US is keyed by its local code and its market, a two letter country code after a dot: 7203.JP is Toyota in Tokyo, SAN.FR Sanofi in Paris. It has no stock file: /api/v1/sec/7203.jp.json answers with `coverage` `holders_only`, from the shard of its first character, /api/v1/holders/0.json, whose `aliases` give the keys written before, without a market (7203 reads as 7203.JP and 7203.SA).
- A row stays under a US ticker when its issuer's file places it in New York, by its exchange, its currency or its identifiers. For a line nothing else places, the US list of tickers decides. The Toronto line of the same shares (RY) also stays under the US ticker. So a stock file's `left_out` is empty. A row in dollars that nothing places abroad counts as a US line, as a few depositary receipts traded in London do (SBID, the GDR of State Bank of India).
- Preferred shares that a file writes under their issuer's common ticker are keyed as that ticker and `.PFD` (JPM.PFD), apart from the common stock.
- A few keys are not tickers but codes of digits and a letter, which an issuer's file gives in place of a ticker, usually for a line whose ticker changed or was delisted. When such a code enters a fund at about the weight of a ticker that exits, and the reverse follows a file later, it is the same security keyed two ways, not a trade.

#### How SEC filings are keyed

Filings identify most stocks by ISIN rather than by ticker, and neither ISINs nor CUSIPs are published here. A position is keyed by the ticker the filing gives it, or by the ticker the same security carries in the issuer files and in other funds' filings, or failing both by OpenFIGI's open mapping. What cannot be keyed is left out and counted in `unmapped_pct`. A row's company is read first from the issuer's Legal Entity Identifier where the filing gives one, so Merck KGaA is never taken for Merck & Co. LEIs are not published either.

Only funds with at least half of their assets in stock are in this layer, because their holdings are stocks that a ticker keys. Fixed income funds have files of their own, and so do the funds that mix asset classes. Leveraged and inverse funds are served apart, as derivative-based funds, since their stock rows alone would understate what they carry in swaps and futures. Funds holding more stock than their net assets are served with the funds that mix asset classes. A ticker listed under `abroad` in a fund file is a foreign company's local code that the US list gives to another company, and that fund is not counted among the US company's holders. Where an issuer file exists for a fund it is always the one served, because it is newer.

#### Sponsor files

A fund too new for a Form N-PORT is served from the holdings its sponsor publishes (`sponsor_files`), by ticker with identifiers dropped, from sponsors whose terms allow it. `file_date` and `source_url` say which file. No overlap; its Form N-PORT replaces it.

#### Prospectus files

A fund with no holdings file has its prospectus's objective, quoted, in a file (`prospectus`). No holdings; its first holdings filing replaces it.

### Holdings history

What changed in each fund from one issuer file to the next, one fund per request, weights only.

The archive began on 2026-09-03 and keeps one snapshot per fund and file date: 16,327 so far. It holds files dated from 2026-07-31 for the 53 funds whose issuer publishes monthly. For the others, the first file is dated between 2026-09-01 and 2026-09-03 for 525 funds (SPY: 2026-09-02) and on 2026-09-22 or later for 119. https://tickerinside.com/api/v1/history.json gives each fund's first file date. In status.json, `data.archive.since` is the day the archive began; in history.json, `since` is the oldest file date.

https://tickerinside.com/api/v1/history.json lists the funds. /api/v1/history/{ticker}.json gives one fund's file dates and each step from a file to the next, with the lines that entered, exited and moved by 0.05 points or more. It also gives how the fund's overlap with its ten closest funds moved. Each step names the file it is compared with, so a gap in the archive or a monthly file shows. SPY's file of 2026-09-18 added BE, ILMN and P and dropped TAP, BLDR and TTD; XSMO's of 2026-09-21, against its file of 2026-09-19, added 66 names and dropped 59, 49.3 points of names turnover.

- `names_turnover_pp`: half the weight that entered plus the weight that exited, in percentage points, what the change of names carried.
- `weights_moved_pp`: half the sum of the absolute changes of weight over every line. It includes price drift, which moves every weight a little each day, so it is not turnover.
- `traded_pp`: what the share counts say was traded, in percentage points of assets: each line's weight times the change of its quantity beyond the fund's own growth, a split left out, plus the lines that entered and exited, halved. Null until a fund has 20 steps whose two files carry share counts.
- `restated`: a step across a change of the keys or of the reading of the files, such as the move to keys with a market (7203.JP). It lists the old keys and the weight the new reading adds or takes away, and no trades. It has no `entered`, `exited` or `moved`, so read them with a default, such as `step.get("entered", [])`; the snapshots give only the count of positions that day.
- `reverted`: the entered lines the fund held two files earlier, most often a line the issuer's file left out for a day. That exit and this entry are a glitch in the file, not trades.

Quarterly holdings since 2019, /api/v1/quarterly/{ticker}.json: each report a US ETF listed today filed on SEC Form N-PORT, with its date, filing, position count, top 10 weight and ten largest positions, companies under their ticker today, CC BY 4.0. /api/v1/history/{ticker}/{date}.json gives every position of the latest report on or before the date (`holdings_as_of`, beside `requested_date`); 404 reasons: `before_first_report`, `not_in_sec_history` (SPY, DIA, GLD), `holdings_at_date_not_enabled`, `invalid_date`.

The file by file history above is not under CC BY 4.0. The history terms let anyone use it per request, commercial use included, credited with a link to the file wherever the medium allows one and by name where it does not, the link marked as you choose. They do not cover republishing the archive as a whole, or fetching many funds' history on a schedule to store it: https://tickerinside.com/legal/#history

### Cite this data

Every fund, stock and comparison file carries `cite_as`, a citation line built the same way in each. For VOO:

```text
TickerInside, Vanguard S&P 500 ETF (VOO), holdings from the issuer's file of 2026-08-31, https://tickerinside.com/etf/voo/, CC BY 4.0
```

Credit TickerInside with a link to the page the figure comes from (`cite_as` gives it) wherever the medium allows a link, and by name where it does not. How you mark the link is up to you. `cite_html` is the same link, ready to paste into a page:

```html
<a href="https://tickerinside.com/etf/voo/">TickerInside</a> (https://tickerinside.com/etf/voo/)
```

The index and list files have no `cite_as`; they carry `license` and `attribution`, and a figure taken from them is cited with the dataset reference:

```text
TickerInside (2026). US ETF holdings, data through 2026-10-12. https://tickerinside.com/. CC BY 4.0.
```

Every line as Markdown, HTML, BibTeX, CSL-JSON, a notebook cell and one sentence for an AI answer: https://tickerinside.com/attribution/

### Licence and fair use

- Licence: CC BY 4.0, with attribution to TickerInside: a link to the page the figure comes from wherever the medium allows a link, and the name where it does not, the link marked as you choose. The holdings history and the ETF flows computed from it are the exception: they have terms of their own at https://tickerinside.com/legal/#history.
- Current snapshots and computed figures: CC BY 4.0, permanently for everything already published. It covers TickerInside's contribution to the holdings served today, the reverse index and every figure computed from them; credit TickerInside with a link to the page the figure comes from wherever the medium allows a link, and by name where it does not; how you mark the link is up to you. The positions are facts as each issuer publishes them, so check the issuer's terms before bulk commercial reuse.
- SEC filings: The SEC's Form N-PORT data sets are US government works in the public domain. The fund files TickerInside derives from them are served under CC BY 4.0 like everything else, and each cites its filing. The counts of shares outstanding in the ownership ledger are facts the companies state on the covers of their SEC filings, read from the SEC's XBRL data, and each figure links its filing.
- Holdings history: Built from the issuer files kept since 2026-09-03 and served one fund per request, weights only, under the history terms of the legal notice (/legal/#history), not under CC BY 4.0: free per request, commercial use included, credited to TickerInside with a link to the file wherever the medium allows one, and by name where it does not, the link marked as you choose; republishing the archive as a whole and extracting it systematically are not allowed.
- ETF flows: Computed from the same archive, as sums over funds and never one fund's share counts: the summary (/api/v1/flows.json), its CSV twin (/api/v1/flows.csv), each security's answer (/api/v1/flows/) and the feeds (/feeds/flows.xml, and one per fund and per stock under /feeds/), under the history terms of the legal notice (/legal/#history), not under CC BY 4.0: free per request, commercial use included, credited to TickerInside with a link to the file wherever the medium allows one, and by name where it does not, the link marked as you choose; a feed reader may poll the feeds, while fetching the answers of many securities on a schedule to keep them is not allowed.
- Sources: issuers' public holdings files, the SEC's public Form N-PORT data sets, the fee tables funds file with the SEC, the shares outstanding companies report to the SEC in XBRL, and end of day prices, provided as is, with no warranty of accuracy. It is a measurement, not investment advice.
- Fair use: no key, no account and no per-user quota. Terms: https://tickerinside.com/terms/
- The whole set: read /api/v1/index.json once, then the fund files, at most once per nightly build rather than polling: the files change once a night. Keeping each night's copy, including to build your own series, is allowed under CC BY 4.0. The history and flows files are not part of the whole set; they have terms of their own: fetch them per fund or security when asked, and poll the feeds with a feed reader.
- User-Agent: please send one that names your program and gives a link or an address, for example `MyApp/1.0 (+https://myapp.example)`.
- A missing field: write to contact@tickerinside.com. Support: https://tickerinside.com/support/

#### What TickerInside does not serve

- Price history and quotes: a file gives its last close and weekly returns, not a price series, and no bid, ask or volume; TickerInside is not licensed to redistribute a price feed.
- Intraday data: everything is built once a night, after the US close.
- Options: no source that allows republishing them.
- Analyst estimates: no source that allows republishing them.
- ISIN, CUSIP and SEDOL: licensed codes, not served. Funds and stocks are keyed by ticker; a key of digits and a letter is an issuer file's code in place of a ticker.

### Status

Data through 2026-10-12. Last build 2026-10-13; the next is due by 2026-10-14 02:00 UTC. 637 of 690 issuer files are under 35 days old. Every build writes https://tickerinside.com/api/v1/status.json, and live checks every five minutes are at https://tickerinside.com/api/v1/uptime.json. Measured from outside every five minutes, 100% of the checks of the API passed, and 100% of the MCP server's, with a median answer of 37 ms on the last full day. The status page, https://tickerinside.com/status/, draws both: 90 days of daily results for each check, the incidents day by day and what the latest build did, with an Atom feed of the incidents.

### Privacy

Each request under /api/ (its pages included), to /mcp, to the A2A agent at /a2a, to /feeds/ or to a file for agents (/llms.txt, /llms-full.txt, /AGENTS.md, /skills/, /.claude-plugin/, /.well-known/ and /context7.json) writes one record of thirteen fields to Cloudflare Workers Analytics Engine, which also stores its time. The home page and the pages under /etf/, /stock/, /agent/, /etf-ownership/, /diversify/ and /xray/ write one only for an assistant fetching them for a person, a visitor sent by an answer engine, or a program whose Accept header ranks text/markdown above text/html; any other visit writes nothing. A 301 redirect writes none, only the request it leads to. The thirteen fields:

- The endpoint: the file family, mcp, feed, doc (a file for agents or a page as Markdown), page or arrival.
- The ticker, file, page or tool asked for, a tool call's tickers, a computed answer's tickers, for an MCP handshake the name and version the client software gives, and the protocol revision an MCP request names when the server does not know it (32 characters at most).
- The kind of client, read from the User-Agent, with each coding agent, AI assistant, crawler and TickerInside client by name.
- The country Cloudflare assigns.
- The first 120 characters of the User-Agent.
- A caller code: the first 16 hexadecimal characters of a SHA-256 hash of the IP address and the User-Agent, salted with a string that includes the day's date.
- The status.
- The Origin host, never the path.
- The Referer host, never the path.
- Sec-Fetch-Site.
- CF-Worker.
- The network name.
- The MCP client's name and version, the answer engine a visitor came from (domain only), or csv and hit for a computed answer.

The caller code changes every day and cannot follow anyone from one day to the next. No IP address is stored, no cookie is set, and of a tool call's arguments only ticker-shaped values are kept, as of a computed answer's query. A computed answer, weights included, is kept in the edge cache for up to a day under its query. The Worker's own status checks are not recorded, and its Workers request logs are turned off. Records are kept three months and are not sold or shared. Questions: contact@tickerinside.com. Policy: https://tickerinside.com/privacy/

### Versioning

The version is in the path; inside v1, fields are added, never removed or retyped. Contract, manifest, changelog, deprecations, corrections, reason codes: https://tickerinside.com/contract/index.md. OpenAPI: https://tickerinside.com/api/openapi.json. Python client: tickerinside 0.5.0 on PyPI. MCP server: tickerinside-mcp 1.13.0 on npm. Every change is dated at https://tickerinside.com/changes/

### Field reference

#### The files

Every field of the files listed in https://tickerinside.com/api/sections/endpoints.md, with its type; "or null" marks a field that can be null, which means missing, never zero. The responses shown, shortened, are from the files of 2026-10-12.

#### What exists: `/api/v1/index.json`

What exists, and the date of the data. Start here if you are pulling the whole set.

```json
{
  "as_of": "2026-10-12",
  "coverage": {"funds": 690, "securities_held": 18758, "…": "1 more field", "sec_nport": 1982, "sec_nport_periods": {"oldest": "2026-01-31", "newest": "2026-08-31"}, "…": "13 more fields"},
  "…": "1 more field",
  "tickers": ["AAXJ", "ACWI", "ACWV", "… 687 more"],
  "tickers_sec": ["AAAA", "AADR", "AAEQ", "… 1,979 more"],
  "…": "6 more fields",
  "written_comparisons": [{"pair": ["VOO", "VTI"], "url": "https://tickerinside.com/api/v1/compare/voo-vs-vti.json"}, "… 14 more"],
  "…": "5 more fields"
}
```

- `as_of` (string): The price date across the whole site.
- `coverage` (object): The coverage counts. funds: the issuer-layer funds. securities_held: the distinct securities they hold. what: the universe in words. sec_nport: the SEC-layer funds, with the oldest and newest quarter end their filings describe in sec_nport_periods, and how old their holdings are on the day of the build in sec_nport_age (the 10th to the 90th percentile in whole months, low_months to high_months, and in words, text); sec_nport_bonds, sec_nport_multi_asset, sec_nport_derivatives, trust_filings, sponsor_files and prospectus, the other layers. Then the figures every page prints: funds_total, every layer, the US ETFs covered; universe, the coverage measured against the US-listed ETFs (see universe.json); stocks_with_file, the stocks with a file under /sec/, and stocks_with_weekly_series, those whose file carries the weekly series, at least 110 of the 156 weekly returns; pages, the funds and stocks with a page; issuers, the issuers whose files are read, largest first.
- `endpoints` (object): The endpoints as URL templates, so a client can find them without reading the reference. fund answers for every fund; etf is the file of a fund listed under tickers_derivative, tickers_trust, tickers_bond, tickers_multi_asset, tickers_sponsor or tickers_prospectus. holders_shard is the template of the holders shards, {c} being the key's first character in lower case, a to z, or 0 for any other. It also gives the OpenAPI description (openapi), the reference in Markdown (docs_markdown), the nightly report (status) and the live checks (uptime).
- `tickers` (array of string): Every issuer-layer fund, as a sorted list: the funds read from their issuers' own files. This is the universe the census of pairs and the file ages count over; a stock page counts these funds and the funds of tickers_sec.
- `tickers_sec` (array of string): Every SEC-layer fund, as a sorted list: the other US stock ETFs, served from their latest SEC Form N-PORT filing. Each has a fund file like the funds above, dated to the quarter end its filing describes, and a page only in a published cohort.
- `tickers_derivative` (array of string): Every derivative-based fund, sorted. Its file is under /etf/.
- `tickers_trust` (array of string): Every trust and commodity pool that files no Form N-PORT, sorted. Its file is under /etf/.
- `tickers_bond` (array of string): Every fixed income fund, sorted. Its file is under /etf/.
- `tickers_multi_asset` (array of string): Every multi-asset fund, sorted. Its file is under /etf/.
- `tickers_sponsor` (array of string): Every sponsor-file fund, sorted.
- `tickers_prospectus` (array of string): Every prospectus-file fund, sorted.
- `written_comparisons` (array of object): The written comparisons: the pairs with a page written by hand, each with the URL of its JSON. A pair's file exists only in the order listed here. Any two tickers above can still be compared from their two fund files.
- `without_file` (object): The directory's tickers with no file, by the reason a fund address's 404 gives.
- `docs` (string): The reference for these endpoints.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.
- `terms` (string): The legal notice: who publishes, the licence of the current snapshots served here, and the separate terms of the historical archive.

#### One fund: `/api/v1/fund/{ticker}.json`

The holdings with their weights and the date of their source, then cost, returns, risk and weekly returns over 156 weeks where the data has them. A figure the data lacks is null, and so is a week without a return; with fewer than 110 weekly returns, weekly is an empty list, or null for a fund from SEC filings. This is the endpoint most things are built from. The funds no issuer file covers are served in the same shape from their latest SEC filing, with eight more fields: report_date, filed, filing_url, net_assets, multi_class, stock_pct, unmapped_pct and abroad. A fund of the other layers answers too, from its /etf/ file.

```json
{
  "ticker": "VOO",
  "…": "5 more fields",
  "source_layer": "issuer",
  "…": "1 more field",
  "as_of": "2026-10-12",
  "holdings_as_of": "2026-08-31",
  "…": "25 more fields",
  "holdings": {"NVDA": 8.0927, "AAPL": 7.0432, "MSFT": 5.7033, "…": "500 more"},
  "weekly": [-0.025, 0.0586, 0.0136, "… 153 more"],
  "weeks_end": "2026-10-12",
  "…": "3 more fields"
}
```

- `ticker` (string): The fund's ticker, upper case.
- `name` (string): The fund's name.
- `page_url` (string or null): The fund's page on the site, or null when it has none yet. Link it when you quote a figure.
- `cite_as` (string): A citation line for a quoted figure: the fund, its source file and that file's date, a URL to check it, and the licence.
- `cite_html` (string): The credit as HTML: a link to the page cite_as names, then its address.
- `source_layer` (string): Where the holdings come from. issuer: the issuer's own file (the issuer layer). sec_nport: the fund's latest public SEC Form N-PORT filing (the SEC layer), whose holdings are the portfolio at the quarter end it describes (report_date), not on the day you read them; index.json coverage.sec_nport_age says how old the layer's holdings are on the day of the build. sec_nport_derivatives: a derivative-based fund, with its contracts apart from its holdings. sec_nport_bonds: a fixed income fund. sec_nport_multi_asset: a fund of funds or of several asset classes. trust_filings: a trust or commodity pool that files no Form N-PORT, from its own SEC filing. sponsor_files, prospectus: see /api/#sponsor-files.
- `category` (object): TickerInside's category (id, label, group, rule, measures): https://tickerinside.com/etf/category/
- `as_of` (string or null): The price date: the date of the price data behind every return and risk figure here. Null for an SEC-layer fund whose weekly is null.
- `holdings_as_of` (string or null): The date of the holdings: the date of the issuer's file, or for an SEC-layer fund the quarter end its filing describes. It is often weeks older than as_of, and often differs from the other fund's in a comparison, so quote it with any holdings figure. It can also be later than as_of, since some issuers date their file with the next business day.
- `expense_ratio` (number or null): Annual cost as a percentage of assets: 0.03 means three basis points, or $3 a year on $10,000. From the fund's newest SEC filing that states it, after any fee waiver when the filing gives both figures, else from the market data. Null when neither gives one. Never read a null as zero.
- `expense_ratio_gross` (number or null): The total of the filing's fee table before any waiver, in percent, which counts the fees of the funds it holds; expense_ratio when there is no waiver. Null unless expense_ratio is from a filing.
- `expense_ratio_source` (string or null): Where expense_ratio comes from. sec_filing: the fee table the filing tags by share class, from the SEC's risk/return data sets or the filing itself. sec_filing_text: the fee table's text, read in a newer prospectus, where no other figure exists or one agrees with it. market_data: undated, also where the filing read is over a year old and differs, or is not matched to the fund. Null when expense_ratio is null.
- `expense_ratio_as_of` (string or null): The day that filing reached the SEC, or null.
- `expense_ratio_filing_url` (string or null): That filing on EDGAR, or null.
- `yield` (number or null): Trailing twelve month distribution yield, as a percentage.
- `aum_b` (number or null): Assets under management, in billions of US dollars, rounded to 0.1, from the market data, read on aum_date. For a Vanguard fund it is the whole fund, every share class together; etf_class_net_assets_b is the ETF's own class. Null when the market data gives no size, the usual case for an SEC-layer fund, whose size is then net_assets on report_date.
- `aum_source` (string or null): Where aum_b comes from. market_data: read on aum_date. market_data_kept: the latest read gave no size, so the last size known is kept, with the day it was read, for 30 days at most. Null when aum_b is null.
- `aum_date` (string or null): The day aum_b was read from the market data. Null when aum_b is null, or for a size read before the day was recorded.
- `etf_class_net_assets_b` (number or null): For a Vanguard fund, the net assets of its ETF share class alone, in billions of US dollars, as Vanguard states them. Such a fund's ETF is one class of a fund that also has mutual fund classes. Every value held in /api/v1/sec/{ticker}.json is computed from it for such a fund. Null for any other fund.
- `etf_class_net_assets_as_of` (string or null): The date Vanguard gives for etf_class_net_assets_b. Null when it is.
- `positions` (integer): How many positions the holdings map lists; filing_lines or file_lines count every line of a fund of another layer.
- `breakdown` (object or null): In percent of the fund, to four decimals: sectors_pct, no_sector_pct, sector_coverage_pct, sectors_stated (true from 50%), other_funds_pct, mega_cap_tech_pct (Apple, Microsoft, Nvidia, Alphabet, Amazon, Meta Platforms, Broadcom and Tesla), top10_us_companies_pct, countries_pct, no_country_pct (lines of no known country), answer, method. Null for another layer.
- `vol` (number or null): Annualised standard deviation of weekly total returns over three years, as a percentage.
- `beta` (number or null): Sensitivity to the S&P 500, from three years of weekly returns. 1.00 means it has moved with the index.
- `mdd3` (number or null): Largest peak to trough decline over three years, measured on weekly closes. Negative.
- `r1` (number or null): Cumulative total return over one year, as a percentage. Not annualised.
- `r3` (number or null): Cumulative total return over three years, as a percentage. Not annualised.
- `r5` (number or null): Cumulative total return over five years, as a percentage. Not annualised.
- `last_close` (number or null): The last closing price, raw, in the fund's trading currency. Returns use dividend-adjusted closes; this figure is the market close as traded.
- `last_close_date` (string or null): The date of that close.
- `day_change_pct` (number or null): The move from the previous close to the last, as a percentage.
- `high_52w` (number or null): The highest raw close over the last 252 trading days.
- `low_52w` (number or null): The lowest raw close over the last 252 trading days.
- `currency` (string or null): The trading currency of the price fields.
- `holdings` (object): The positions, as a map of key to percentage weight. For the issuer layer, the positions as the issuer publishes them. For an SEC-layer fund, every position the filing lets us key to a ticker; the rest is counted in unmapped_pct. A key is the ticker of a US line (a share class keeps its dot, BRK.B), or a local code and its market for a line listed abroad (7203.JP). Preferred shares filed under their issuer's common ticker are keyed as that ticker and .PFD (JPM.PFD), apart from the common stock. A key of digits and a letter is a code the issuer's file gives in place of a ticker, usually for a line whose ticker changed or was delisted. The overlap between two stock funds is computed from this field. For a fund of another layer, tickers, then other lines in lower case: a bond as issuer, coupon and maturity, else its name; never an identifier or a contract.
- `weekly` (array of number or null): 156 weekly total returns as decimals, oldest first, ending at as_of. The weeks are the same in every fund and stock file, so any basket of them can be correlated without matching dates. A week is null when its return cannot be computed, because the fund's prices begin later or a weekly close is missing. An empty list for an issuer-layer fund with fewer than 110 weekly returns in those weeks, and null for a fund of another layer with fewer.
- `weeks_end` (string or null): The date the weekly series ends, always as_of. It is set even when weekly is an empty list, and null, like as_of, when weekly is null.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to the page cite_as names where the medium allows one, the name where it does not.
- `source` (string): Where the method behind these figures is written down.

What a fund from SEC filings adds, from /api/v1/fund/smh.json:

- `report_date` (string or null): The quarter end the filing describes, the end of one of the fund's fiscal quarters. The holdings are the portfolio on that day, not on the day you read them; index.json coverage.sec_nport_age says how old the layer's holdings are on the day of the build. Quote this date with any figure from these holdings.
- `filed` (string or null): The day the filing reached the SEC, usually about 60 days after report_date.
- `filing_url` (string or null): The filing itself on SEC EDGAR, to check any figure against the source.
- `net_assets` (integer or null): The fund's net assets on report_date, in US dollars, as filed. For an ETF that is one share class of a larger fund, it covers every class.
- `multi_class` (boolean): True when the ETF is one share class of a fund that also has mutual fund classes. The holdings and weights are then the whole fund's, which is the same portfolio, and so is net_assets.
- `stock_pct` (number): How much of net assets the filing lists as common or preferred stock, long positions only. Cash, bonds, derivatives and collateral make up the rest and are not in holdings.
- `unmapped_pct` (number): The part of stock_pct that could not be tied to a ticker and is left out of holdings, usually private companies, warrants and thinly traded foreign lines. The holdings add up to stock_pct minus this.
- `abroad` (array of string): Tickers in holdings that are a foreign company's local code, where the US list gives the same ticker to another company. Such a position is the foreign company, so the fund is not listed among the US company's holders in /api/v1/sec/. Lines listed abroad now carry their market (ALV.DE is Allianz, ALV is Autoliv), so this list is normally empty.

What a fund of another layer adds, from /api/v1/fund/bnd.json:

- `holdings_kind` (string): What the map of a fund of another layer holds: bond, multi-asset, stock, derivative (stocks held outright, never contracts), commodity (a trust's asset) or prospectus (none yet).
- `listed_pct` (number): The share of net assets the map shows, in percent. Not listed is not the same as not held.
- `etf_file` (string): The /etf/ file this answer is built from, whose fields follow.

The fields the other layers add (`summary`, `composition`, `lines`, `fixed_income`, `derivatives`, `structure`) are in https://tickerinside.com/api/sections/endpoints/fund.md.

The holdings map and the weekly series make this file enough on its own. The overlap of any two stock ETFs is a walk over two holdings maps, and a covariance matrix for any basket is a walk over their weekly series.

#### One stock: `/api/v1/sec/{ticker}.json`

In this path sec stands for security, not the SEC: the file is one stock and the funds that hold it, and a fund's own holdings are in /api/v1/fund/{ticker}.json. Name, sector, market cap, valuation, returns, risk, the funds that hold it from issuer files and from SEC filings, and its weekly returns over the same 156 weeks as the fund files. Every stock in the price data with at least 110 weekly returns in those weeks has a file here, whether or not any covered fund holds it. A stock with fewer has one when a fund read from an issuer file or a stock ETF from SEC filings holds it in a file dated since it listed, the price data has its closes since its listing, or a year of them, the last at most five sessions old, and Nasdaq Trader's directory lists it under its name. weekly is then an empty list, the figures over three and five years and the correlated stocks are null or empty, calendar is given once 40 of the last 52 weeks have a return, and r1 once the weekly closes cover a full year.

```json
{
  "ticker": "NVDA",
  "…": "25 more fields",
  "held_by": 177,
  "heaviest": ["GXPT", 19.82],
  "held_by_sec_nport": 569,
  "holders": [["GXPT", 19.82, "2026-10-12"], ["VGT", 17.7869, "2026-08-31"], "… 175 more"],
  "holders_sec_nport": [["SMHX", 18.5624, "2026-06-30"], "… 568 more"],
  "…": "1 more field",
  "left_out": [],
  "…": "2 more fields",
  "etf_ownership": {"pct_lower_bound": 11.36, "basis": "company", "company": "Nvidia", "…": "3 more fields", "shares_outstanding_as_of": "2026-08-21", "…": "6 more fields", "holdings_dates": {"oldest": "2026-05-29", "newest": "2026-10-13"}, "…": "9 more fields"},
  "…": "11 more fields",
  "weekly": [-0.0214, 0.1112, 0.074, "… 153 more"],
  "…": "4 more fields"
}
```

- `ticker` (string): The stock's ticker, upper case.
- `name` (string): The company's name.
- `page_url` (string or null): The stock's page on the site, or null when it has none. Link this when quoting the figures.
- `cite_as` (string): A citation line for a quoted figure: company, sources and date, a URL to check it, licence.
- `cite_html` (string): The credit as HTML: a link to the page cite_as names, then its address.
- `sector` (string): The company's sector where the data classifies it, or "US Listed" when it does not, which is the case for most stocks.
- `industry` (string or null): The finest level of that classification under the sector, such as Semiconductors or Regional Banks; null when sector is "US Listed".
- `as_of` (string): The price date: the date of the price data behind every figure here.
- `page` (boolean): True when the stock has a written page at /stock/{ticker}/. Every stock here has this file whether or not it has a page.
- `cap_b` (number or null): Market capitalisation, in billions of US dollars.
- `pe` (number or null): Trailing price to earnings ratio.
- `yield` (null): Trailing twelve month dividend yield, as a percentage.
- `vol` (number or null): Annualised standard deviation of weekly total returns over three years, as a percentage.
- `beta` (number or null): Sensitivity to the S&P 500, from three years of weekly returns.
- `mdd3` (number or null): Largest peak to trough decline over three years, measured on weekly closes. Negative.
- `r1` (number or null): Cumulative total return over one year, as a percentage. Not annualised.
- `r3` (number or null): Cumulative total return over three years, as a percentage. Not annualised.
- `r5` (number or null): Cumulative total return over five years, as a percentage. Not annualised.
- `last_close` (number): The last closing price, raw, in the trading currency. Returns use dividend-adjusted closes; this is the close as traded.
- `last_close_date` (string): The date of that close.
- `day_change_pct` (number): The move from the previous close to the last, as a percentage.
- `high_52w` (number): The highest raw close over the last 252 trading days, or since the listing for a stock listed less than a year ago.
- `low_52w` (number): The lowest raw close over the last 252 trading days, or since the listing for a stock listed less than a year ago.
- `currency` (string): The trading currency of the price fields.
- `calendar` (object or null): Total return by calendar year, as a percentage, the current year to date.
- `held_by` (integer): How many issuer-layer funds hold it, the rows of holders. The stock's page counts these less left_out, with the SEC-layer funds of held_by_sec_nport, as holders_all lists them.
- `heaviest` ([ticker, weight] or null): The issuer-layer fund that gives it the largest weight, as [fund ticker, weight percent]. Null when none of them holds it.
- `held_by_sec_nport` (integer): How many SEC-layer funds hold it, the rows of holders_sec_nport. The stock's page counts them with the issuer-layer funds and lists them in a table of their own, each linked to its filing.
- `holders` (array of [ticker, weight, date]): Every issuer-layer fund that holds it, heaviest first, as [fund ticker, weight percent, date of that fund's holdings file]. The same rows as the holders index, in the stock's own file.
- `holders_sec_nport` (array of [ticker, weight, date]): The SEC-layer funds that hold it, heaviest first, as [fund ticker, weight percent, the quarter end the filing describes]. They are months older than holders, so they are kept apart. A fund whose row under this ticker is a foreign company's local code is not listed. A filing names a security by its ISIN, which does not say where the fund bought it. So shares that trade in New York and abroad on one ISIN (AstraZeneca, TotalEnergies, Ferrari) are listed here for the funds whose stocks are mostly on US ISINs, and under the line abroad (AZN.GB) for the others. A preferred share is keyed by its issuer's common ticker, as the filings key it, so a preferred stock fund can appear here. For a stock whose weekly is empty, a row can be dated before its first close in the price data. Such a row can be another security that had the ticker, or the company's shares abroad before it listed in New York, and etf_ownership does not count it (before_first_close).
- `synthetic_exposure` (array of object): The derivative-based funds whose swaps, futures or options reference the stock, largest first: fund, exposure (long, short, long and short, options, not stated), long_pct, short_pct, options, instruments, complete, report_date. Notional exposure, not shares held: in no holder list, rank or etf_ownership.
- `left_out` (array of string or null): An empty list for a stock with a page, and null without one; kept for compatibility. Before lines listed abroad were keyed with their market (7203.JP), it named the issuer-layer funds whose row under the ticker was most likely a company listed abroad under the same code. Today a row stays under a US ticker when its issuer's file places it in New York, by its exchange, its currency or its identifiers, with the US list for a line nothing else places. The Toronto line of the same shares as a New York line also stays under the US ticker (RY). A row in dollars that nothing places abroad counts as a US line, as a few depositary receipts traded in London do (SBID, the GDR of State Bank of India).
- `same_code_abroad` (array of [key, name]): The lines listed outside the United States under the same local code, as [key, company name], most widely held first. Each is another security, and often another company: SAN.ES is Banco Santander in Madrid and SAN.FR Sanofi in Paris, beside SAN, the Santander ADR. Their issuer-layer holders are under those keys in the holders index. Their SEC-layer holders are in holders_sec_nport of the shard of their first character (/api/v1/holders/a.json for AZN.GB). An empty list when there is none.
- `earlier_key_reads_as` (array of string or null): The keys this ticker reads as now, this ticker among them, when it was also the key of other lines before lines listed abroad were keyed with their market. CCO, Clear Channel Outdoor, was also Cameco's Toronto code, so it reads as CCO and CCJ; SAN reads as SAN, SAN.ES and SAN.FR. The same list as the aliases of the holders index. Null when the ticker was only ever this line.
- `etf_ownership` (object): The stock's line of the ETF ownership ledger: the share of the company's shares outstanding that the covered US ETFs hold, at least, with its parts and dates, or why no figure is published. Its fields are described below; the method, with its test vectors, is /api/v1/methods.json.
- `etf_holders_since_2019` (object or null): How many of today's US stock ETFs held it in their SEC reports, each quarter: answer to quote, quarters oldest first. Null when fewer than two quarters held it.
- `holders_all` (array of [fund, weight, date, layer, rank, positions, value]): Every covered fund holding the stock, both layers in one list, heaviest first, an issuer file first on a tie. Each row is [fund ticker, weight percent, date of its holdings, layer, rank of the stock in the fund, the fund's positions, value held in millions of US dollars]. The layer is issuer for an issuer's own file, or sec_nport for an SEC Form N-PORT filing, dated to the quarter end it describes. The rank is 1 plus the number of the fund's positions that weigh more. The value held is the weight times the fund's net assets as published. Those are the ETF share class's for a Vanguard fund (etf_class_net_assets_b), aum_b for another issuer-layer fund, and net_assets for an SEC-layer fund. A value keeps the significant figures of the less precise of the weight and the net assets, three at most. VOO's value is 81000 on net assets Vanguard prints as $1.0 trillion, two figures; a fund with aum_b of 41.8 gives three. The value is null when the fund has no net assets, or has them to fewer than two figures, or when its filing covers mutual fund classes too. Fewer than two figures means aum_b under 1.0, which the market data gives to $0.1 billion, so 0.1 is anything from 0.05 to 0.15. rank_summary counts these funds in funds_without_value. The rows are the funds of holders, less left_out, and of holders_sec_nport; no fund is in both layers. A short position, a negative weight in a long and short fund, is listed with its negative weight and value. It is not a holding: rank_summary counts it in short_positions, and by_issuer, top_by_value, membership and answer leave it out.
- `rank_summary` (object): How many of the holders have the stock as their largest holding (top_holding_in) and among their ten largest (top10_in), of how many (funds), in all and by layer. It also counts the holders with no value held (funds_without_value) and the funds short the stock (short_positions), which are not counted as holders.
- `top_by_value` (array of object): The ten holders with the most dollars in the stock, most first, each with the net assets its value is computed from and their date. Only funds with a value are ranked, so a fund whose net assets are known to fewer than two figures is not.
- `membership` (array of object): Whether the stock is in VOO, SPY, IVV, QQQ, VTI and SCHD, and in the three largest sector or industry funds holding it. Each comes with its weight, the stock's rank in it, its positions and the date of its holdings. The sector funds are ranked by the net assets a value is computed from. A fund is a sector fund when its TickerInside category is in the sector group (/etf/category/), else when its name names a sector or an industry. A fund no layer covers is left out.
- `by_issuer` (array of object): The six issuers whose covered funds hold the most dollars of the stock, most first. For each: how many of its funds hold it, the dollars in millions over the funds with a value, how many have none, the heaviest weight as [fund, weight percent] and the largest holding as [fund, millions of US dollars]. An issuer file names its issuer. An SEC-layer fund takes the issuer its name and the trust that filed it give, and one with none is left out.
- `fee_per_1000` (array of object): The five cheapest ways to hold the stock through a covered fund: what the fund's expense ratio costs a year for each $1,000 of the stock held through it. It is 1000 times the expense ratio over the weight, both in percent. Only funds whose expense ratio is in the data are listed.
- `name_collision` (object or null): The covered funds whose name contains the company's name as whole words (JPMorgan Realty Income ETF for Realty Income), which a reader can take for the company or for its own fund. It gives the name compared, how many funds, and up to ten of them, holders first, each with whether it holds the stock. Null when there is none, or when the name is one word found in the funds of three issuers or more: a word of fund names more than a company's.
- `answer` (string): One sentence to quote, built from the fields above and etf_ownership, every figure with its date. It says how many covered funds hold the stock, by layer, and how many have it as their largest holding. It says where it weighs most (under 0.01% for a weight that rounds to nothing) and where the most dollars are, with about as many figures as the value has (under $0.1 million below that). It ends with the ownership figure when there is one: every class counted when it counts several, also when no fund holds this class. It opens on the name the stock's page uses, or for a stock without a page on the company's name as etf_ownership.company gives it, with the class when the figure counts several. It calls the funds the ownership figure counts "N of them" when they are among the holders it has just counted and the figure counts one class.
- `least_correlated` (array of [ticker, correlation, name]): The eight stocks least correlated with this one over the last 104 of the same weekly returns, as [ticker, correlation, name]. The candidates are stocks held by ten or more covered funds, so every neighbour is reachable through ETFs. A measurement of co-movement, not a recommendation.
- `most_correlated` (array of [ticker, correlation, name]): The eight most correlated, same shape and same candidate set.
- `weekly` (array of number): 156 weekly total returns as decimals, oldest first, ending at as_of: the same weeks as the fund files, so a stock and a fund correlate with the same arithmetic as two funds. A week is null when its return cannot be computed, because the stock's prices begin later or a weekly close is missing. At least 110 of the 156 are numbers. It is an empty list for a stock with fewer that has a file by the rule of this endpoint: its vol, beta, mdd3, r3 and r5 are then null and its correlated stocks empty lists.
- `weeks_end` (string): The last date covered by the weekly series.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to the page cite_as names where the medium allows one, the name where it does not.
- `source` (string): Where the method behind these figures is written down.

The etf_ownership object:

- `pct_lower_bound` (number or null): At least this percent of the shares outstanding is held by the covered US ETFs counted, rounded down to two decimals. It is of the company, every class counted, when basis is company, and of this ticker's class alone when basis is class. It is a lower bound: funds not covered, and covered funds whose count could not be used, are not in it. One exception: the count of shares outstanding is used when it is at most 2% below a current independent count, so the figure can be up to about 2% of itself too high. Null when no figure is published; refused says why.
- `basis` (string or null): What the percent is of. company: all the company's shares outstanding, every class rolled up. class: this ticker's class alone, which is not the company's figure. It is company when shares_outstanding covers every class, rolled up (Alphabet's three classes; Berkshire's class A counted as 1,500 class B shares). It is also company when that count is the one count the company's cover gives and the company has one class of stock. It is class when the roll-up over the cover's classes does not check out against an independent count while this class's count does. It is also class when the one count the SEC gives is short of an independent company count and cannot be shown to be the company's. That happens when the filing names another class of stock (Mobileye's class B, Plains GP's class B shares), or when the count is a frames row. Null when no figure is published.
- `company` (string or null): The company the figure is about, as cite_as names it. It is the stock's name without what names the listing rather than the company. That is its class (Alphabet Inc., not Alphabet Inc. (Class A)), a depositary receipt, a registry share or a closed-end fund (Ares Capital Corporation, not Ares Capital Corporation - Closed End Fund). It keeps a leading "The" when the company's name has one (The Walt Disney Company). On a company basis the figure covers every class; on a class basis cite_as names the class by its ticker (the outstanding shares of the PAGP class). Null when no figure is published.
- `shares_held` (integer or null): The shares the counted funds hold, in shares of this ticker's class, of every listed class on a company basis. Issuer files enter it only as a sum over at least two of them, never a single issuer file's count. SEC filings are public one by one, so a figure can rest on a single filing.
- `shares_held_by_layer` (object or null): shares_held split between the issuers' own files (issuer_files) and SEC Form N-PORT filings (sec_nport).
- `shares_outstanding` (integer or null): The company's shares outstanding, in shares of this ticker's class, as the cover of a periodic report states them in the SEC's XBRL data: a 10-K, 10-Q, 20-F or 40-F, amendments and transition reports included. It is the most recent count read; its date is shares_outstanding_as_of and its filing shares_outstanding_filing. On a class basis, it is the class's own count.
- `shares_outstanding_as_of` (string or null): The date the cover counts the shares on. It is not the date of the holdings, which holdings_dates gives.
- `shares_outstanding_filing` (string or null): The filing on SEC EDGAR the count comes from, to check it against the source.
- `funds_holding` (object or null): How many covered funds list the stock, any listed class on a company basis, by layer: issuer_files and sec_nport. A fund holding two classes is one fund.
- `funds_counted` (object or null): How many of them are counted in shares_held, by layer. The others are in not_counted.
- `funds_prorated` (integer or null): How many of the counted funds are Vanguard ETFs. A Vanguard file lists the whole fund, every share class together, so each is counted for its ETF class only. Its shares are multiplied by the ETF class's net assets over the whole fund's, as Vanguard prints them, each taken at the end of its rounding that keeps the figure a lower bound.
- `not_counted` (object or null): The funds listing the stock that are not counted, by reason; each reason is explained under not_counted in /api/v1/methods.json. no_share_count: the file gives no share count. through_fund: held through another covered fund. preferred_fund: a preferred stock fund. preferred_row: a row the file names as a preferred or depositary share. price_mismatch: a value per share that is not the stock's price. value_mismatch: a file whose counts or values do not match its weights times the fund's stated net assets. no_value_check: a file without market values, and no net assets to check it against. no_class_size: a Vanguard file without its class sizes. whole_series: a filing covering mutual fund classes. before_split: a row dated before a split of the stock. before_first_close: a row dated before the stock's first close in the price data. single_issuer_file: the only issuer file counted. A fund holding two classes of the company is one fund here, and it is not listed when either of its rows is counted; rows_not_counted has the rows.
- `rows_not_counted` (object or null): The rows not counted, one per fund and class, by the same reasons. It holds the row of a fund counted through another class that is itself left out, such as a preferred depositary share filed under the common's ticker. On a class basis, only this ticker's rows.
- `holdings_dates` (object or null): The oldest and newest holdings dates of the counted funds. A filing describes a quarter end months back, so the two are often far apart.
- `holdings_dates_by_layer` (object or null): The same for each layer, issuer_files and sec_nport; null for a layer with no fund counted.
- `classes` (array of object or null): For a company with several classes of stock, one entry per class: class, tickers (empty for an unlisted class), shares_outstanding and as_of. weight is set where one share counts for more than one share of this ticker's class. shares_held and pct_lower_bound are set where the class's own count checks out against its ticker's and the class figure is at least 0.01%, and are null otherwise. Null for a company with one class.
- `refused` (string or null): Why no figure is published, as a code: no_sec_count, class_unknown, count_too_old, count_date_invalid, no_independent_count, split_between_dates, count_below_independent, count_mismatch, no_fund_counted, under_0_01_pct, above_100 or held_back. Null when a figure is published.
- `refused_reason` (string or null): The same reason in words.
- `held_back` (object or null): Null on a normal night. When tonight's ledger failed its checks and was held back, the same object as held_back in /api/v1/ownership.json, and the figure here, if any, is from the last ledger that passed, with its own dates.
- `method` (string): The method and its version, ti-ownership/1. A change to what it computes from inputs it already accepted is a new version.
- `method_url` (string): Where the method is written down, with its test vectors.
- `cite_as` (string or null): A citation line for the figure: company, the figure, the method, the holdings dates and the date of the count, a URL to check it, licence. Null when no figure is published.
- `cite_html` (string or null): The credit as HTML: a link to the page cite_as names, then its address. Null when no figure is published.

The rank_summary object:

- `funds` (integer): How many covered funds hold the stock: the rows of holders_all less short_positions.
- `top_holding_in` (integer): How many of them have it as their largest holding, a tie included.
- `top10_in` (integer): How many have it among their ten largest holdings.
- `funds_without_value` (integer): How many of them have no value held: no net assets, net assets known to fewer than two figures, or a filing that covers mutual fund classes too.
- `short_positions` (integer): How many funds hold the stock short, a negative weight in holders_all: listed there, never counted as holders.
- `by_layer` (object): The same three counts for each layer, issuer and sec_nport.

A line of top_by_value:

- `fund` (string): The fund's ticker.
- `value_usd_m` (number): The value of the stock the fund holds, in millions of US dollars: weight times net_assets_b, to the significant figures of the less precise of the two, three at most.
- `weight` (number): The stock's weight in the fund, in percent.
- `holdings_as_of` (string): The date of the fund's holdings.
- `layer` (string): issuer or sec_nport.
- `net_assets_b` (number): The net assets the value is computed from, in billions of US dollars.
- `net_assets_basis` (string): What they are: etf_class, a Vanguard ETF share class alone; fund, aum_b from the market data; filing, the net assets the fund's SEC filing states.
- `net_assets_as_of` (string or null): Their date: Vanguard's, the day aum_b was read, or the filing's quarter end. Null when not known.

A line of membership:

- `fund` (string): The fund's ticker.
- `kind` (string): broad for VOO, SPY, IVV, QQQ, VTI and SCHD, sector for a sector or industry fund.
- `category` (string): The fund's category label, or null.
- `held` (boolean): Whether the fund holds the stock.
- `weight` (number or null): Its weight in percent, or null.
- `rank_in_fund` (integer or null): Its rank in the fund, 1 for the largest holding, or null.
- `positions` (integer): How many positions the fund holds.
- `holdings_as_of` (string): The date of the fund's holdings.
- `layer` (string): issuer or sec_nport.

A line of by_issuer:

- `issuer` (string): The issuer, as the issuer files name it (iShares, SPDR, Vanguard, Invesco, Global X) or as a fund's name or filer gives it.
- `funds` (integer): How many of its covered funds hold the stock.
- `value_usd_m` (number or null): The value they hold, in millions of US dollars, over the funds with a value, to the precision of the least precise of them; null when none has one.
- `funds_without_value` (integer): How many of them have no value, for want of published net assets known to two figures or more.
- `heaviest` ([ticker, weight]): The fund that gives the stock its largest weight, as [fund, weight percent].
- `largest` (array of number or null): The fund holding the most dollars of it, as [fund, millions of US dollars], or null.

A line of fee_per_1000:

- `fund` (string): The fund's ticker.
- `fee_usd_per_1000` (number): US dollars a year of the fund's expense ratio for each $1,000 of the stock held through it.
- `expense_ratio` (number): The fund's expense ratio, in percent a year.
- `weight` (number): The stock's weight in the fund, in percent.
- `holdings_as_of` (string): The date of the fund's holdings.
- `layer` (string): issuer or sec_nport.

The name_collision object:

- `name` (string): The company's name as compared: its trade name less the words a filed name ends in (SoFi, not SoFi Technologies).
- `count` (integer): How many covered funds' names contain it.
- `funds` (array of object): Up to ten of them, holders first: fund, name, holds, weight (null when it does not hold the stock), holdings_as_of and layer.

A security covered funds hold with no file of its own, a stock the price data does not list or lists too few weekly returns for, or a line listed abroad (7203.JP), answers with "coverage": "holders_only": its holders from the shard of its first character, each dated, the price and return fields null, and none of the fields built from each fund's file or the ledger, such as etf_ownership and holders_all. A 404 means no covered fund holds the key.

#### A written comparison: `/api/v1/compare/{a}-vs-{b}.json`

One of the 15 written comparisons, the pairs listed in index.json written_comparisons: overlap measured three ways, correlation over one, three and five years, and a summary of each fund. The file is written in the order listed there (voo-vs-vti); the other order answers 301 to it.

```json
{
  "pair": ["VOO", "VTI"],
  "…": "1 more field",
  "holdings_as_of": {"VOO": "2026-08-31", "VTI": "2026-08-31"},
  "overlap": {"by_weight": 88.9, "share_of_a": 99.9, "share_of_b": 88.9, "n_shared": 501, "…": "7 more fields"},
  "correlation": {"c1y": 0.99, "c3y": 1.0, "c5y": 1.0, "…": "2 more fields"},
  "…": "2 more fields",
  "cite_as": "TickerInside, VOO vs VTI, holdings files of 2026-08-31 and 2026-08-31, https://tickerinside.com/compare/voo-vs-vti/, CC BY 4.0",
  "…": "4 more fields"
}
```

- `pair` (array of string): The two tickers, in the order of the file's address and of index.json written_comparisons: this file is /compare/{a}-vs-{b}.json with a first. The other order answers 301 to this file.
- `as_of` (string): The price date.
- `holdings_as_of` (object): The date of each fund's holdings file, keyed by ticker. The two are often weeks apart.
- `overlap` (object): Holdings overlap, measured three ways; its fields are described below.
- `correlation` (object): Correlation of weekly total returns, and the annualised covariance; its fields are described below.
- `funds` (object): A summary of each fund, keyed by ticker, as the comparison page shows it; its fields are described below. The full file of each fund, with its holdings, is /api/v1/fund/{ticker}.json.
- `page_url` (string): The written comparison's page, to link when you quote a figure.
- `cite_as` (string): A citation line for a quoted figure: the pair, both holdings file dates, the page, and the licence.
- `cite_html` (string): The credit as HTML: a link to the page cite_as names, then its address.
- `source` (string): The written comparison's page, which this data belongs to.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to the page cite_as names where the medium allows one, the name where it does not.

The overlap object:

- `by_weight` (number): The sum, over every ticker both funds hold, of the smaller of its two weights. Symmetric: the headline figure. Tickers are compared as keys, so GOOG and GOOGL count as two.
- `share_of_a` (number): The part of the first fund's weight that sits in tickers the second also holds, in percent of the first fund's listed total weight, which can differ a little from 100. Not symmetric.
- `share_of_b` (number): The same measure from the second fund's side. When share_of_a is far above share_of_b, the first fund is mostly contained in the second.
- `n_shared` (integer): How many tickers appear in both funds. The Python client calls it companies_in_both.
- `n_a` (integer): How many positions the first fund holds, as positions in its fund file.
- `n_b` (integer): How many positions the second fund holds.
- `top` (array of object): The largest shared positions: ticker, name, wa and wb, the weight in each fund rounded to two decimals, and min, the smaller of the two. pa and pb are the same weights scaled so that the largest in the list is 100, for drawing bars.
- `only_a` (array of object): The largest positions of the first fund that the second does not hold: ticker, name and w, the weight.
- `only_b` (array of object): The largest positions of the second fund that the first does not hold, in the same shape.
- `method` (string): ti-overlap/1, in methods.json.
- `method_url` (string): Its address.

The correlation object:

- `c1y` (number): Correlation of weekly total returns over one year, 52 weeks.
- `c3y` (number): Correlation over three years, 156 weeks: the figure the comparison pages quote.
- `c5y` (number): Correlation over five years, 260 weeks.
- `cov` (number): Annualised covariance of the weekly returns over three years, in percent squared. Divided by the two funds' vol, it gives c3y back, which is how a reader can check it.
- `weeks` (array of string): The 52 weekly dates of the one-year spark series in funds. They are not the weeks of c3y or c5y.

A fund's summary, in funds:

- `ticker` (string): The fund's ticker.
- `name` (string): The fund's name.
- `kind` (string): etf.
- `group` (string): The fund's sector or category in the market data, or null.
- `vol` (number): Annualised standard deviation of weekly total returns over three years, as a percentage.
- `beta` (number): Sensitivity to the S&P 500, from three years of weekly returns.
- `r1` (number): Cumulative total return over one year, as a percentage.
- `r3` (number): Cumulative total return over three years, as a percentage.
- `r5` (number): Cumulative total return over five years, as a percentage.
- `mdd3` (number): Largest peak to trough decline over three years, on weekly closes, as a percentage. Negative.
- `cal` (object): Total return by calendar year, as a percentage, keyed by year; the current year to date.
- `er` (number): The expense ratio, in percent of assets a year, or null.
- `yield` (number): Trailing twelve month distribution yield, as a percentage, or null.
- `aum_b` (number): Assets under management, in billions of US dollars, or null.
- `family` (string): The fund family in the market data, or null.
- `cat` (string): The fund's category, TickerInside's own, or null.
- `nh` (integer): How many positions have a weight above zero. It can be lower than positions in the fund file and n_a or n_b, which count every line.
- `spark` (array of number): The last 52 weekly closes, indexed to 100 at the first: the one-year line the page draws.
- `px` (object): The latest raw close: last, the price; date, its date; d1, the move from the previous close in percent; hi52 and lo52, the highest and lowest close over 252 trading days; ccy, the trading currency.

Any other pair answers 404, reason no_written_comparison, with the two fund files. From them, compute the overlap by weight: the sum, over the tickers both hold, of the smaller of the two weights, as the overlap example does.

#### Every fund, one line each: `/api/v1/funds.json`

Ticker, name, category, cost, position count, and whether the fund has a written page: the funds read from issuer files under funds, and those from SEC filings under sec_funds. The list to iterate before pulling fund files.

```json
{
  "as_of": "2026-10-12",
  "count": 690,
  "…": "2 more fields",
  "funds": [{"t": "AAXJ", "n": "iShares MSCI All Country Asia ex Japan ETF", "c": "Asia Pacific ex Japan", "cat_id": "asia-pacific-ex-japan", "er": 0.72, "p": 949, "issuer": "iShares", "aum_b": 4.0, "page": true, "url": "https://tickerinside.com/etf/aaxj/", "api": "https://tickerinside.com/api/v1/fund/aaxj.json"}, "… 689 more"],
  "sec_count": 1982,
  "…": "1 more field",
  "sec_funds": [{"t": "AAAA", "n": "Amplius Aggressive Asset Allocation ETF", "c": "Aggressive Allocation", "cat_id": "allocation-aggressive", "er": 0.49, "p": 43, "api": "https://tickerinside.com/api/v1/fund/aaaa.json", "report_date": "2026-07-31", "issuer": null, "aum_b": null, "net_assets": 278318309, "page": true, "url": "https://tickerinside.com/etf/aaaa/"}, "… 1,981 more"],
  "…": "8 more fields"
}
```

- `as_of` (string): The price date.
- `count` (integer): How many issuer-layer funds there are, the length of funds. Each has a /fund/ file.
- `with_a_page` (integer): How many funds have a page, in every list of this file.
- `note` (string): How to read the entries.
- `funds` (array of object): One entry per issuer-layer fund: t the ticker, n the name, c the category's name (Large Blend for US Large Blend, as before 9 October 2026), cat_id its id, er the expense ratio, p the number of positions. issuer is the fund's issuer, named as in index.json coverage.issuers, and aum_b its assets in billions of US dollars, as in its fund file; either can be null. page says whether it has a page, url is that page or null, and api is its file.
- `sec_count` (integer): How many SEC-layer funds there are, the length of sec_funds.
- `sec_note` (string): How to read sec_funds.
- `sec_funds` (array of object): One entry per SEC-layer fund: t, n, c, cat_id, er, p, issuer, aum_b and api as above, then report_date, the quarter end the filing describes, and net_assets, in US dollars on that date. er is null where the cost is not in the data, never zero, and aum_b is null unless the market data gives the fund's size; the filing's figure is net_assets. issuer is read from the fund's name and checked against the trust that filed it, or null when neither says. page and url as in funds.
- `sponsor_funds` (array of object): One entry per sponsor-file fund, as sec_funds.
- `prospectus_funds` (array of object): One entry per prospectus-file fund, as sec_funds, with filed and form.
- `bond_funds` (array of object): One entry per fixed income fund, as sec_funds; p counts its filing's lines.
- `multi_asset_funds` (array of object): One entry per multi-asset fund, as sec_funds.
- `derivative_funds` (array of object): One entry per derivative-based fund, as sec_funds; report_date is the quarter end its filing describes. The files of this and the next three lists are under /etf/, at each entry's api. In them, page and url are given only for a fund that has a page.
- `trust_funds` (array of object): One entry per trust or commodity pool, as sec_funds; report_date is the period its filing describes, null for a fund too new to have filed a report.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.

#### Who holds what, issuer files: `/api/v1/holders.json`

The reverse index of the 690 issuer files: for each of the 18,758 securities their funds hold, which of them hold it and at what weight. One file of 5.3 MB, the right shape for a client that loads it once and walks it. SEC-layer funds are not in it. A stock's SEC-layer holders are in /api/v1/sec/{ticker}.json, under holders_sec_nport, and those of a key with no stock file are in the shard of its first character, /api/v1/holders/{c}.json.

```json
{
  "as_of": "2026-10-12",
  "holdings_as_of": {"CNRG": "2026-10-12", "CWI": "2026-10-12", "…": "688 more"},
  "…": "1 more field",
  "securities": 18758,
  "…": "2 more fields",
  "holders": {"NVDA": [["GXPT", 19.82], ["VGT", 17.7869], "… 175 more"], "…": "18,757 more securities"},
  "…": "4 more fields"
}
```

- `as_of` (string): The price date.
- `holdings_as_of` (object): The date of each issuer-layer fund's holdings file, keyed by ticker.
- `funds` (object): Ticker to fund name for the issuer-layer funds, and for a few other funds the price data names, and for other funds the price data names. Use index.json tickers, not this map, as the list of covered funds.
- `securities` (integer): How many distinct securities the issuer-layer funds hold between them, the length of holders.
- `names` (object): Ticker to company name for every security the data can name: from the price data for the stocks with a history, from the issuer files for the rest.
- `note` (string): How to read the holders map.
- `holders` (object of arrays of [ticker, weight]): The index itself: for each security, the issuer-layer funds that hold it, as [fund ticker, weight percent], heaviest first. A security is one listed line. A US line is keyed by its ticker, and a dot and one letter mark a US share class (BRK.B). Any other line is keyed by its local code and its market, a dot and a two letter country code (7203.JP, SAN.FR). The Toronto line of a Canadian company that also trades in New York is the same shares, under the US ticker (RY). Preferred shares a file writes under their issuer's common ticker are under that ticker and .PFD, three letters and never a market (JPM.PFD). That key holds every series of JPMorgan's preferred stock a fund holds, and in a preferred stock fund any other income security filed under the ticker, such as a business development company's listed notes. It is a US line of its own, so a preferred stock fund is never listed among the holders of the common stock.
- `aliases` (object): The keys written before lines listed abroad were keyed with their market, when a local code alone was the key. Each maps to the keys it reads as now, the US line first and then the heaviest: 7203 reads as 7203.JP (Toyota) and 7203.SA (Elm), A005930 as 005930.KR. A key that became several was several companies or lines under one code. The shard of each old key's first character lists them all. This file leaves out a key that reads only as itself with its market after it (NESN as NESN.CH).
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.
- `source` (string): Where the method behind these figures is written down.

#### Who holds what, one first character: `/api/v1/holders/{c}.json`

The reverse index split by the first character of the key: a.json to z.json, and 0.json for a key that starts with any other character (7203.JP is in 0.json, AZN.GB in a.json). Each shard holds the part of holders.json for its keys, with their names and figures under facts. It also holds what holders.json does not: the SEC-layer funds that hold a key with no stock file, such as a line listed abroad, under holders_sec_nport, and the old keys of its first character under aliases. It is the source of the holders-only answers under /sec/. 0.json is the largest shard (3.1 MB). The same content is split again by the key's first digit, in /api/v1/holders/0/0.json to /api/v1/holders/0/9.json (7203.JP is in 0/7.json), for a client that wants a smaller file.

```json
{
  "as_of": "2026-10-12",
  "holdings_as_of": {"CNRG": "2026-10-12", "CWI": "2026-10-12", "…": "688 more"},
  "…": "1 more field",
  "facts": {"7203.JP": {"n": "Toyota Motor Corp"}},
  "holders": {"7203.JP": [["EWJV", 6.5507], ["RXI", 3.5548], "… 50 more"], "…": "7,022 more keys"},
  "holders_sec_nport": {"7203.JP": [["IQDG", 4.095], ["BBJP", 3.9873], "… 71 more"], "…": "7,476 more keys"},
  "sec_nport_as_of": {"IQDG": "2026-06-30", "BBJP": "2026-07-31", "…": "626 more"},
  "aliases": {"7203": ["7203.JP", "7203.SA"]},
  "…": "2 more fields"
}
```

- `as_of` (string): The price date.
- `holdings_as_of` (object): The date of each issuer-layer fund's holdings file, keyed by ticker, for every issuer-layer fund.
- `funds` (object): Ticker to fund name for the issuer-layer funds. The names of SEC-layer funds are in /api/v1/funds.json, under sec_funds.
- `facts` (object): For each key of this shard the data can describe: n, the name, and where known r1, r3, vol, mdd3, cap_b, pe and yield, in the units of a stock file. page is true when the stock has a page.
- `holders` (object of arrays of [ticker, weight]): The part of holders.json for the keys of this shard: each key to the issuer-layer funds that hold it, as [fund ticker, weight percent], heaviest first. Each row's date is in holdings_as_of.
- `holders_sec_nport` (object of arrays of [ticker, weight]): Each key of this shard that has no stock file, such as a line listed abroad, to the SEC-layer funds that hold it, as [fund ticker, weight percent], heaviest first. Each row's date is in sec_nport_as_of. A key with a stock file has its SEC-layer holders in that file.
- `sec_nport_as_of` (object): Each SEC-layer fund listed in holders_sec_nport, to the quarter end its filing describes.
- `aliases` (object): The old keys whose first character is this shard's, each with the keys it reads as now: 7203 reads as 7203.JP and 7203.SA. Unlike holders.json, it also lists a key that reads only as itself with its market (NESN as NESN.CH). Absent from a shard with no old key.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.

Ask for the key's first character in lower case, or 0 when it is not a letter. The files are a.json to z.json, 0.json, and 0/0.json to 0/9.json; any other address under /api/v1/holders/ answers 404, reason not_a_shard.

#### Every security, one line each: `/api/v1/securities.json`

Every security the funds of the 690 issuer files hold, with how many of them hold it and its largest weight, in one file of 938 KB. The list to walk before asking for stock files: its last place says whether a stock file exists.

```json
{
  "as_of": "2026-10-12",
  "count": 18758,
  "…": "1 more field",
  "securities": [["MSFT", 177, 14.54, "Microsoft", 1, 1], ["NVDA", 177, 19.82, "Nvidia", 1, 1], "… 18,756 more"],
  "…": "2 more fields"
}
```

- `as_of` (string): The price date.
- `count` (integer): How many securities are listed, the length of securities.
- `note` (string): How to read the entries.
- `securities` (array of [ticker, funds, weight, name, page, file]): One entry per security held by the issuer-layer funds, the most widely held first. Each is [ticker, how many of those funds hold it, its largest weight in any of them, company name, 1 when it has a page at /stock/{ticker}/, 1 when /api/v1/sec/{ticker}.json is a stock file, not a holders_only answer].
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.

#### ETF ownership, every stock: `/api/v1/ownership.json`

The ETF ownership ledger. For each of the 3,604 stocks with a figure, most held first: the share of its shares outstanding held by the covered US ETFs, at least, how many funds were counted, and the basis. The basis is company when the percent is of the company, every class counted, and class when it is of the ticker's class alone. Then the share of the money in the covered US stock ETFs that sits in the ten largest US companies, and the companies held by the most funds. Each figure's parts and dates are in the stock's file, /api/v1/sec/{ticker}.json, under etf_ownership: shares_held, shares_outstanding and shares_outstanding_as_of, funds_counted, and holdings_dates {oldest, newest}. Here as_of is the newest holdings date counted, not a price date.

```json
{
  "as_of": "2026-10-13",
  "method": "ti-ownership/1",
  "…": "1 more field",
  "count": 3604,
  "…": "1 more field",
  "stocks": [["EU", 35.0, 23, "company"], ["ATEN", 34.9, 105, "company"], ["URG", 34.8, 21, "company"], "… 3,601 more"],
  "…": "2 more fields",
  "top10_share": {"pct": 28.1, "companies": ["NVDA", "AAPL", "GOOGL", "… 7 more"], "funds": 1487, "…": "2 more fields"},
  "…": "5 more fields"
}
```

- `as_of` (string): The newest holdings date among the issuer files the ledger was counted from. Here as_of is a holdings date, not the price date.
- `method` (string): The method and its version, ti-ownership/1.
- `method_url` (string): Where the method is written down, with its test vectors.
- `count` (integer): How many stocks have a figure, the length of stocks.
- `note` (string): How to read the entries.
- `stocks` (array of [ticker, percent, funds, basis]): One entry per stock with a figure, most held first, as [ticker, at least this percent held by the covered US ETFs, how many funds were counted, basis]. basis is as in the stock file. company: the percent is of the company's shares outstanding, every class counted. class: it is of the ticker's class alone, which is not the company's figure (Clearway's class C, while its classes A, B and D are left out). Two tickers of one company on a company basis carry the same figure.
- `refused` (object): How many stocks with a file have no figure, by reason.
- `refused_reasons` (object): Those reasons in words.
- `top10_share` (object): The share of the money in the covered US stock ETFs that sits in the ten largest US companies by market value. It gives pct, the companies, and funds, how many funds it is measured over: those whose net assets are at least 80% in US-listed stocks. It also gives how many such funds were left out for want of stated net assets, and the oldest and newest date of the net assets used. Each fund counts by its own net assets, a Vanguard fund by its ETF class's alone. The ten are ranked among every US company a covered fund holds, whether or not it has a stock file here. The weight of a company without a file counts as US stock like any other.
- `most_widely_held` (array of [ticker, company, funds, percent, basis]): The 25 companies held by the most covered funds, both layers, one line per company. Each line is [ticker, company name, how many covered funds hold any of its listed classes, the ticker's pct_lower_bound or null, its basis or null]. A fund holding two classes of the company (GOOGL and GOOG) is one fund. The ticker is the company's class held by the most funds. Its pct_lower_bound is that stock file's figure, of the company or of the ticker's class alone as basis says (Visa's is its class A's). A fund whose row under a ticker is another security is not counted: a preferred stock fund, a row named as a preferred share, or a filing whose row is listed under abroad. A line listed abroad has a key of its own (7203.JP beside TM) and is never counted for a US company.
- `held_back` (object or null): Null on a normal night. When tonight's ledger is held back, the figures served are those of the last ledger that passed, each with its own dates, and this says why. reason is above_100 when more than five stocks come to over 100% with no split to explain them; failures says how many, and examples which. It is fewer_figures when tonight's ledger has more than 20% fewer figures than the last one that passed (figures, last_figures), a night that lost an input. It is error when the ledger could not be computed tonight; top10_share is then null and most_widely_held empty. A fewer_figures hold lasts at most seven days of holdings dates (last_as_of is the date of the ledger served); after that the lower count is published. The ledger served keeps only the stocks that have a file tonight.
- `docs` (string): Where this file is documented.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.

The top10_share object:

- `pct` (number): The share, in percent, rounded to one decimal. A share of the money, not a bound, so it is rounded to nearest.
- `companies` (array of string): The ten companies, one ticker each: the largest by the market data's capitalisation among the US companies any covered fund holds. A US company is a stock the price data places in a sector, or one whose company files 10-K and 10-Q reports with the SEC. A company with no stock file here is ranked like the others, and its weight in each fund counts in pct. A stock has a file with at least 110 of the 156 weekly returns, or with fewer when a fund read from an issuer file or a stock ETF from SEC filings holds it in a file dated since it listed, the price data has its closes since its listing, or a year of them, the last at most five sessions old, and Nasdaq Trader's directory lists it under its name.
- `funds` (integer): How many funds it is measured over.
- `funds_without_net_assets` (integer): How many US stock funds were left out because their files state no net assets.
- `net_assets_dates` (object): The oldest and newest date of the net assets used: issuer figures are current, SEC filings months old.

A lower bound, never an estimate of the whole: shares held by ETFs outside the coverage, and by covered funds whose count could not be used, are not in it. One exception: the count of shares outstanding is used when it is at most 2% below a current independent count, so a figure can be up to about 2% of itself too high. The holdings and the count of shares carry different dates, both published.

#### Methods and test vectors: `/api/v1/methods.json`

Each method a published figure names in its method field, with its version, formula, rules and test vectors: inputs with the output the method gives, to check an implementation against. It holds ti-ownership/1, the ETF ownership ledger, ti-ownership-index/1 and ti-overlap/1.

```json
{
  "…": "1 more field",
  "methods": [{"id": "ti-ownership/1", "…": "5 more fields", "formula": "pct_lower_bound = floor(100 * shares_held / shares_outstanding, 2 decimals)", "…": "5 more fields", "vectors": [{"name": "two issuer files and one SEC filing", "input": {"ticker": "AAA", "shares_outstanding": {"as_of": "2026-08-01", "classes": [{"class": null, "tickers": ["AAA"], "shares": 1000000}]}, "independent": {"AAA": {"class": 1000000, "company": 1000000}}, "funds": [{"fund": "F1", "layer": "issuer_files", "as_of": "2026-09-24", "shares": {"AAA": 30000}}, {"fund": "F2", "layer": "issuer_files", "as_of": "2026-09-23", "shares": {"AAA": 20000}}, {"fund": "S1", "layer": "sec_nport", "as_of": "2026-06-30", "shares": {"AAA": 5555}}]}, "output": {"pct_lower_bound": 5.55, "basis": "company", "shares_held": 55555, "shares_outstanding": 1000000, "funds_counted": {"issuer_files": 2, "sec_nport": 1}, "not_counted": {}}}, "… 17 more"]}],
  "…": "3 more fields"
}
```

- `note` (string): How methods are named and versioned.
- `methods` (array of object): One entry per method; its fields are described below.
- `docs` (string): Where this file is documented.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.

A method:

- `id` (string): The name and version a published figure gives in its method field.
- `name` (string): The method in words.
- `version` (integer): The version number. Fields are added; a change to what the method computes from inputs it already accepted is a new id, and a rule for an input it did not accept before is listed under changes.
- `since` (string): The first day figures were published under this version.
- `changes` (array of object): The rules added to this version for an input it did not accept before, each with since, the first day it was published, rule, its code under not_counted, and what, the change in words. Every earlier test vector keeps its output.
- `measures` (string): What the figure is, in one sentence.
- `formula` (string): The figure as a formula.
- `definitions` (object): What each term of the formula is.
- `rules` (array of string): The rules of the method, in words.
- `not_counted` (object): Each reason an input is left out, as a code and in words.
- `refusals` (object): Each reason no figure is given, as a code and in words.
- `vector_format` (string): The shape of a test vector's input and output.
- `vectors` (array of object): Inputs with the output the method gives for them, to check an implementation against.

A change to what a method computes from inputs it already accepted is a new version, never an edit of the one published. A rule for an input it did not accept before is added to the version with its own test vector, and changes gives the day it was first published.

#### Holdings history, every fund: `/api/v1/history.json`

Every issuer-layer fund that has a history here, with the dates of its oldest and newest files in the archive, how many file dates it holds, how often the issuer publishes, and the address of its history file.

```json
{
  "as_of": "2026-10-13",
  "since": "2026-07-31",
  "count": 697,
  "funds": [{"t": "AAXJ", "first": "2026-09-02", "last": "2026-10-12", "file_dates": 28, "cadence": "daily", "traded_pp_from": "2026-09-29", "ended": null, "url": "https://tickerinside.com/api/v1/history/aaxj.json"}, "… 696 more"],
  "…": "3 more fields",
  "license": "TickerInside history terms",
  "terms": "https://tickerinside.com/legal/#history",
  "…": "1 more field"
}
```

- `as_of` (string): The newest file date any fund's history reaches. Here as_of is a holdings file date, not the price date.
- `since` (string): The oldest file date any fund's history starts from. It is not the day the archive began, which is since in status.json, under data.archive.
- `count` (integer): How many funds have a history file, the length of funds.
- `funds` (array of object): One entry per fund with a history, ended or not; its fields are described below.
- `holdings_at` (string or null): The address of a fund's holdings at a date, with {ticker} and {date} to fill, once it is served; null until then. Today any valid date answers 404 not_covered, with reason holdings_at_date_not_enabled and the address of the fund's changes file.
- `note` (string): How to read the files.
- `docs` (string): Where the files are documented.
- `license` (string): The terms the history is published under: TickerInside's history terms, not CC BY 4.0.
- `terms` (string): The terms in full, on the legal notice.
- `attribution` (string): How to credit it, a link to the file where the medium allows one and the name where it does not, then what the history terms allow.

A fund entry:

- `t` (string): The fund's ticker.
- `first` (string): The date of the oldest file of the fund in the archive.
- `last` (string): The date of the newest.
- `file_dates` (integer): How many file dates the archive holds for the fund.
- `cadence` (string): daily when the median gap between two files is at most four days, monthly when it is 25 to 35 days, irregular otherwise; null with a single file.
- `traded_pp_from` (string or null): The date of the first step whose two files both carry share counts, from which traded_pp is measured; null when there is none yet.
- `ended` (string or null): Last issuer file's date once no longer read, else null.
- `url` (string): The fund's history file.

Not under CC BY 4.0: the history terms apply (license, terms). Fetching this list or many funds' history files on a schedule to store them is not allowed.

#### One fund's holdings history: `/api/v1/history/{ticker}.json`

Each file date the archive holds for the fund, with its position count and top 10 weight. Then each step from a file to the next: the lines that entered and exited with their weights, the lines whose weight moved by 0.05 points or more, and three measures of the step. Then how its overlap with its ten closest funds moved. Every step names the file it is compared with, so a gap in the archive or a monthly file shows. A step across a change of the keys is restated, not read as trades: it has no entered, exited or moved, so read them with a default.

```json
{
  "ticker": "SPY",
  "…": "3 more fields",
  "first": "2026-09-02",
  "last": "2026-10-12",
  "…": "1 more field",
  "cadence": "daily",
  "snapshots": {"columns": ["holdings_as_of", "positions", "top10_weight", "key_scheme", "unplaced"], "rows": [["2026-09-02", 504, 37.95, 1, []], ["2026-09-03", 504, 38.13, 1, []], "… 26 more"]},
  "…": "5 more fields",
  "changes": ["… 10 earlier steps", {"date": "2026-09-18", "previous": "2026-09-17", "entered": [["BE", 0.1187], ["ILMN", 0.0549], ["P", 0.0525]], "exited": [["TAP", 0.0095], ["BLDR", 0.0094], ["TTD", 0.0093]], "moved": [["NVDA", 8.0659, 8.1587], ["AVGO", 2.4967, 2.576], ["AAPL", 7.515, 7.4406], "… 3 more"], "moved_below_threshold": 471, "names_turnover_pp": 0.1272, "weights_moved_pp": 0.9545, "traded_pp": null}, "… 16 later steps"],
  "overlap_history": {"with_top_funds_by_overlap": 10, "series": {"IVVW": [["2026-09-24", 99.7], ["2026-09-25", 99.7], "… 11 more"]}},
  "…": "3 more fields",
  "cite_as": "TickerInside, SPDR S&P 500 ETF Trust (SPY), holdings history from the issuer's files of 2026-09-02 to 2026-10-12, https://tickerinside.com/api/v1/history/spy.json",
  "…": "5 more fields"
}
```

- `ticker` (string): The fund's ticker.
- `name` (string): The fund's name.
- `source_layer` (string): Always issuer: the history is read from the issuers' own files. The other funds known from SEC filings have none.
- `key_scheme` (integer): The keys the holdings are given in: 2, the scheme of today's files, where a line listed abroad carries its market (7203.JP). Older files are read in these keys.
- `first` (string): The date of the oldest file of the fund in the archive.
- `last` (string): The date of the newest.
- `file_dates` (integer): How many file dates the archive holds for the fund.
- `cadence` (string): daily, monthly or irregular, from the gaps between the file dates; null with a single file.
- `snapshots` (object): One row per file date, oldest first, with the columns named in columns.
- `moved_threshold_pp` (number): How far a weight has to move, in percentage points, for its line to be listed under moved: 0.05.
- `traded_min_pairs` (integer): How many steps with share counts on both sides a fund needs before traded_pp is published: 20.
- `traded_pairs` (integer): How many of the fund's steps have share counts on both sides.
- `traded_pp_from` (string or null): The date of the first of those steps; null when there is none.
- `traded_pp_reason` (string or null): Why traded_pp is null in every step: fewer_than_20_pairs_with_share_counts. Null once it is published.
- `changes` (array): One entry per step from a file to the next, oldest first; its fields are described below.
- `overlap_history` (object): How the fund's overlap by weight with its ten closest funds moved; its fields are described below.
- `holdings_at` (string or null): The address of the fund's holdings at any date, with {date} to fill, once it is served; null until then.
- `fund` (string): The fund's current file, with its holdings today, cost, returns and risk.
- `ended` (object or null): Null while read; once not, last_file, source_layer and note.
- `cite_as` (string): A citation line: the fund, the dates of its oldest and newest files, and this file's address.
- `cite_html` (string): The credit as HTML: a link to this file, then its address.
- `docs` (string): Where the file is documented.
- `license` (string): The terms the history is published under: TickerInside's history terms, not CC BY 4.0.
- `terms` (string): The terms in full, on the legal notice.
- `attribution` (string): How to credit it, a link to the file where the medium allows one and the name where it does not, then what the history terms allow.

The snapshots object:

- `columns` (array of string): The names of the columns of each row. holdings_as_of: the file date. positions: the lines in the file. top10_weight: the weight of its ten largest lines, in percent; null for the files of a fund of funds before its file kept the funds it holds apart from its own lines. key_scheme: the keys the file was written in, 1 or 2. Scheme 1 is for files read before the switch to keys with a market, late in September 2026. The switch date varies by fund (SPY's first scheme 2 file is dated 2026-09-25), and the first scheme 2 step is restated. unplaced: for a file of scheme 1, the old keys that cannot be read as one line today because they stood for two companies in that file (SAN for Santander and Sanofi); null for a file of scheme 2.
- `rows` (array of array): The rows, oldest first.

A step, in changes:

- `date` (string): The date of the file the step leads to.
- `previous` (string): The date of the file it is compared with: the fund's file before it in the archive, days or a month earlier.
- `entered` (array of [key, weight]): The lines in this file that were not in the previous one, as [key, weight percent], heaviest first. Absent from a restated step, which does not say what entered or exited that day; the snapshots give only its count of positions. Read it with a default, such as step.get("entered", []). A key of digits and a letter is a code the issuer's file gives in place of a ticker. When a ticker exits and such a code enters at about the same weight, and the reverse follows, it is the same security re-keyed, not a trade.
- `exited` (array of [key, weight]): The lines in the previous file that are not in this one, as [key, weight percent in the previous file], heaviest first. Absent from a restated step.
- `moved` (array of [key, before, after]): The lines in both files whose weight moved by moved_threshold_pp or more, as [key, weight before, weight after], largest move first. Absent from a restated step.
- `moved_below_threshold` (integer): How many other lines in both files moved by less. Absent from a restated step.
- `names_turnover_pp` (number or null): Half the weight that entered plus the weight that exited, in percentage points: what the change of names carried. Null on a restated step.
- `weights_moved_pp` (number or null): Half the sum of the absolute changes of weight over every line of either file, in percentage points. It includes price drift, which moves every weight a little each day, so it is not turnover. Null on a restated step.
- `traded_pp` (number or null): What the share counts say was traded, in percentage points of assets, when both files carry them and the fund has traded_min_pairs such steps; null otherwise. A line held in both counts its weight times the change of its quantity beyond the fund's own growth, a line that entered or exited its weight, and the sum is halved.
- `reverted` (array of string): The entered lines the fund held two files earlier, most often a line the issuer's file left out for a day. That exit and this entry are a glitch in the file, not trades, and so is a key of digits and a letter that stood in for the line in the file between. Present when there is one.
- `restated` (boolean): true on a step that is a change of the keys or of the reading of the files, not a trade; absent otherwise. A restated step has no entered, exited, moved or moved_below_threshold, so read them with a default. It is set on the step to a file of the current key scheme, where the parser also reads lines the old one dropped. It is set on the first file of a fund of funds that lists the funds it holds apart from their look-through, and on two files whose weights add up to totals 50 points or more apart. It is also set on the first file that keys apart the preferred shares a file writes under their issuer's common ticker (JPM.PFD rather than JPM), and on a date listed after a fix of the reading.
- `reason` (string): Why the step is restated. key_scheme_2: the first file in keys with a market. own_lines_separated: a fund of funds whose earlier files listed the funds it holds beside their look-through, about 200% in all. weight_total_changed: the two totals are 50 points or more apart. weights_from_market_values: weights from market values, or the reverse. preferred_keyed_apart: the preferred shares the file writes under their issuer's common ticker are keyed as that ticker and .PFD, at the weight the common ticker carried. Otherwise, the reason given with a listed date.
- `rekeyed` (array of [old key, array of key]): On a restated step, the old keys that read as other keys today, as [old key, [new keys]]. It covers a spelling brought together (A005930 is 005930.KR), a Toronto code under its New York ticker, and a key that stood for several lines, with the lines the new file holds. It also covers a common ticker whose preferred shares took a key of their own (JPM as [JPM.PFD], or [WFC, WFC.PFD] where the fund holds both).
- `market_added` (integer): On a restated step, how many old keys only took their market (7203 became 7203.JP). Each is in the aliases of the holders shard of its first character.
- `coverage_added_pp` (number): On a restated step, the weight the new file covers beyond the previous one, in percentage points: lines the old reading dropped, or, below zero, weight the old reading counted twice.
- `splits_seen` (array of string): The lines whose quantity moved by a split ratio while their weight did not, left out of traded_pp. Present when there is one.

The overlap_history object:

- `with_top_funds_by_overlap` (integer): How many funds are followed: the funds whose overlap by weight with this one is highest on the latest files, up to ten.
- `series` (object of array of [date, overlap]): For each followed fund, most overlapping first, [date, overlap by weight in percent] on every file date of either fund from the first date both have a file. Each fund is taken at its latest file on or before the date. It is the overlap by weight the comparisons print, computed here from the archived files. A file of the old key scheme is read in today's keys, so a point can differ from what a comparison printed on the day. A series can step where either fund's history is restated.

Weights only: no share count, market value or fund size is served. weights_moved_pp is not turnover, since prices move every weight; traded_pp, from share counts, is. Not under CC BY 4.0: the history terms apply (license, terms). Fetch it per request, one fund at a time; fetching many funds' history on a schedule to store it is not allowed.

#### The nightly report: `/api/v1/status.json`

What the last build did: when it ran, the date of each layer of the data, and the funds still served from an older file. It also gives the pages it dated as modified, and the versions of the API and of the MCP server. The build writes it with the data, so it is exactly as current as the files it describes.

- `schema` (integer): The version of this file's shape: 1. Fields are added and never removed or retyped.
- `built_at` (string): When the build that wrote this file started, in UTC. The nightly build starts at 22:00 UTC each weekday and is due by 02:00 UTC. The site can also be rebuilt during the day, from the data already fetched.
- `run` (object): What the nightly steps reported, when their reports are in the build. run.fetch_holdings, the holdings fetch, publishes only counts, tickers, issuers, dates and a kind of failure. run.fund_figures, the capture of what the issuers state about their funds, which is kept and not served, publishes four totals and nothing else.
- `data` (object): The date of each layer of the data: prices, the issuers' files and the SEC filings, and of the ownership ledger computed from them.
- `pages` (object): How many pages the site publishes, and which of them this build dated as modified in the sitemaps.
- `versions` (object): The API version, and the version of the MCP server as an npm package and at its URL.
- `live` (string): The live checks of the site, made every five minutes: the file documented next.
- `docs` (string): Where this file is documented.
- `license` (string): The licence the data is published under.
- `attribution` (string): How to credit the data: a link to this file where the medium allows one, the name where it does not.

run.fetch_holdings, when the fetch left its report:

- `funds_attempted` (integer): How many issuer files the fetch tried to read.
- `funds_updated` (integer): How many of them were read and accepted, so the fund now carries the file read that night, whether or not its date moved. A Vanguard file is dated at the month end and keeps its date for weeks.
- `funds_newer_file` (integer): How many of those carry a file dated later than the one held before.
- `kept_previous` (array of object): The funds still served from an earlier file, because the new one was refused or missing, or because the issuer no longer lists the fund. Each gives ticker, issuer, since (the first night the fetch found the fund served this way) and holdings_as_of (the date of the file served). The two dates differ: a fund kept since last night can be served from a month end file.
- `failed` (array of object): The funds with a file here whose two attempts both failed that night: ticker, issuer and reason_class. reason_class is http_error (the file could not be downloaded), refused (by the site), empty_file (no holdings came back), rejected_by_gate (its weights did not add up to a whole fund, or its date was too old), parse_error (it could not be read) or other. Each is still served from its earlier file, so it is also in kept_previous.
- `failed_without_file` (integer): How many other funds failed that night that have no file here, such as fixed income funds, whose issuer files the fetch tries and does not serve: a fixed income fund is read from its SEC filing. They are counted rather than listed, and with funds_updated and failed they add up to funds_attempted.

run.fund_figures, when the capture of the issuers' fund figures left its report:

- `run_date` (string): The UTC day the capture ran.
- `funds` (integer): How many funds it captured.
- `deadline_hit` (boolean): True when it ran out of time before every answer was in.
- `warnings` (integer): How many warnings it raised, 0 on a normal night. What they say is not published.

The data object:

- `prices` (object): through, the last close in the price data, which every return and risk figure uses; securities_priced, how many funds and stocks have a weekly series.
- `issuer_files` (object): funds, how many funds are read from their issuers' files; newest and oldest file dates; by_date, how many funds carry each of the eight most recent dates.
- `sec_nport` (object): funds, how many other US stock ETFs are served from SEC filings; dataset, the SEC quarterly data set the layer was last read from (a fund with a newer filing on EDGAR is served from that filing); report_dates, the oldest and newest quarter end the filings describe.
- `universe` (object): The coverage measured against the US-listed ETFs, the block of index.json coverage.universe.
- `archive` (object): What the archive of issuer files holds: funds; snapshots, one per fund and file date; first and last, the oldest and newest file dates; and since, the day the archive began, which is not the oldest file date. What changed in each fund from one file to the next is served under /api/v1/history/, under the history terms.
- `ownership` (object or null): The ETF ownership ledger: method; stocks, how many stocks have a figure; as_of, the newest holdings date it counted; held_back. held_back is true on a night whose ledger failed its checks, when the figures served are those of the last ledger that passed. Null when the build had no ledger.

The pages object:

- `published` (integer): How many pages the site publishes.
- `redated` (integer): How many of them this build dated as modified. Most nights it is a small number: a page is dated only when a reader would notice the change.
- `redated_paths` (array of string): The first 50 of those pages, sorted.

The versions object:

- `api` (string): The API version, which is also the path prefix: v1.
- `mcp_package` (object): The npm package tickerinside-mcp: name, version and its page.
- `mcp_remote` (object): The remote MCP server: its URL and the version it announces.

#### Live checks: `/api/v1/uptime.json`

Whether the site answers now, and how it has answered. Every five minutes the Worker requests a fund page, the API index and an MCP handshake through the public address, and reads the nightly report. This file gives each check's state, its share of passed checks over 24 hours, 7, 30 and 90 days, 90 days of daily figures, the incidents and the deployments. It is computed when asked and kept one minute at the edge.

- `schema` (integer): The version of this file's shape: 1.
- `generated_at` (string): When this answer was computed. The file is kept a minute at the edge.
- `method` (string): How the checks are made, in one paragraph.
- `deployed` (object): The version of the site serving now, or null before the first check saw it.
- `components` (array of object): One entry per check, with the fields of a component.
- `today` (object): Today's figures so far, per check, in the shape of an entry of days.
- `days` (array of object): Up to 90 days of daily figures, newest first: for each check, checks made, failed, no_data (slots with no check), up_pct and, except for the update, p50_ms and p95_ms. For the update, failed counts the checks that found it late.
- `incidents` (array of object): Open incidents first, then those closed in the last 90 days: id, component, kind (down or late), started, ended, minutes and cause. An incident opens after two failed checks in a row and closes after two good ones.
- `status` (string): The nightly report, as served at /api/v1/status.json.
- `docs` (string): Where this file is documented.
- `license` (string): The licence the data is published under.

A component:

- `id` (string): page, api, mcp or update.
- `name` (string): The check in words.
- `check` (string): The request made.
- `state` (string): up or down for page, api and mcp; on time or late for the update; no data when no check has run for 15 minutes; unknown when the record could not be read.
- `since` (string): When the current state began, within the last day, or null when it has held all day.
- `last_check` (string): When the last check ran, in UTC.
- `last_ms` (integer): How long its answer took, in milliseconds, measured from the Cloudflare location that ran the check.
- `uptime_pct` (object): The share of checks that passed over the last 24 hours, 7, 30 and 90 days. Slots with no check are left out.
- `no_data_pct_90d` (number): The share of five-minute slots with no check over the period on record, up to 90 days.
- `open_incident` (string): The id of the open incident on this check, or null.
- `ms_24h` (object): The median and 95th percentile answer time over the last 24 hours, in milliseconds.
- `server_version` (string): For the MCP server, the version its handshake announced.
- `last_build` (string): For the update, the built_at of the last build seen.
- `prices_through` (string): For the update, the price date of that build.
- `next_expected_by` (string): For the update, the deadline of the next nightly build: 02:00 UTC the morning after a weekday.

The checks run on Cloudflare, like the site. An outage of Cloudflare itself stops them too, so it shows as slots with no data, which are never counted as up.

## Field dictionary

Every field of every data file under /api/v1, with its unit, where it comes from and what the licence says of it. The two files about the service, status.json and uptime.json, are described in the reference above. CC BY 4.0 covers TickerInside's own contribution and does not extend to rights held by others. Weights and returns are percentages (VOO's file of 2026-08-31 lists NVDA at 8.0927, which is 8.0927%); weekly returns are decimals.

Licence, by the word in the last column:

- own: CC BY 4.0: TickerInside's own work.
- issuer: CC BY 4.0 for TickerInside's contribution. The positions are facts as each issuer publishes them: check the issuer's terms before bulk commercial reuse.
- SEC: CC BY 4.0 for TickerInside's contribution, from the SEC's public filings and data sets.
- public: Public domain: the counts of shares outstanding companies state on the covers of their SEC filings, from the SEC's XBRL data; the roll-up over classes is TickerInside's arithmetic.
- market: CC BY 4.0 for TickerInside's contribution, from third-party market data provided as is.
- history: The TickerInside history terms, not CC BY 4.0 (/legal/#history): free per request, commercial use included, credited with a link to the file wherever the medium allows one, and by name where it does not, the link marked as you choose; not the archive as a whole, and no systematic extraction.
- third-party: Third-party sector labels from a public list of S&P 500 members; not covered by CC BY 4.0.

| File | Field | Type | Unit | Source | Licence |
|---|---|---|---|---|---|
| /api/v1/index.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/index.json | `coverage` | object | structure, see note | TickerInside metadata | own |
| /api/v1/index.json | `endpoints` | object | structure, see note | TickerInside metadata | own |
| /api/v1/index.json | `tickers` | array of string | structure, see note | TickerInside metadata | own |
| /api/v1/index.json | `tickers_sec` | array of string | structure, see note | SEC filings | SEC |
| /api/v1/index.json | `tickers_derivative` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/index.json | `tickers_trust` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/index.json | `tickers_bond` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/index.json | `tickers_multi_asset` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/index.json | `tickers_sponsor` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/index.json | `tickers_prospectus` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/index.json | `written_comparisons` | array of object | structure, see note | TickerInside metadata | own |
| /api/v1/index.json | `docs` | string | text | TickerInside metadata | own |
| /api/v1/index.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/index.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/index.json | `terms` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json | `ticker` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json | `name` | string | text | market data | market |
| /api/v1/fund/{ticker}.json | `page_url` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json | `cite_as` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json | `cite_html` | string | text | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `source_layer` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/fund/{ticker}.json | `holdings_as_of` | string | date, YYYY-MM-DD | issuer file or SEC filing | issuer |
| /api/v1/fund/{ticker}.json | `expense_ratio` | number | percent of assets per year | SEC filing or market data | market |
| /api/v1/fund/{ticker}.json | `expense_ratio_gross` | number | percent of assets per year | SEC filing | SEC |
| /api/v1/fund/{ticker}.json | `expense_ratio_source` | string | text | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `expense_ratio_as_of` | string | date, YYYY-MM-DD | SEC filing | SEC |
| /api/v1/fund/{ticker}.json | `expense_ratio_filing_url` | string | text | SEC filing | SEC |
| /api/v1/fund/{ticker}.json | `yield` | number | percent | market data | market |
| /api/v1/fund/{ticker}.json | `aum_b` | number | billions of US dollars | market data | market |
| /api/v1/fund/{ticker}.json | `aum_source` | string | text | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `aum_date` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/fund/{ticker}.json | `etf_class_net_assets_b` | number | billions of US dollars | issuer file | issuer |
| /api/v1/fund/{ticker}.json | `etf_class_net_assets_as_of` | string | date, YYYY-MM-DD | issuer file | issuer |
| /api/v1/fund/{ticker}.json | `positions` | integer | count | issuer file or SEC filing | issuer |
| /api/v1/fund/{ticker}.json | `vol` | number | percent, annualised | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `beta` | number | ratio, against SPY's weekly returns | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `mdd3` | number | percent, negative | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `r1` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `r3` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `r5` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `last_close` | number | trading currency | market data | market |
| /api/v1/fund/{ticker}.json | `last_close_date` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/fund/{ticker}.json | `day_change_pct` | number | percent | market data | market |
| /api/v1/fund/{ticker}.json | `high_52w` | number | trading currency | market data | market |
| /api/v1/fund/{ticker}.json | `low_52w` | number | trading currency | market data | market |
| /api/v1/fund/{ticker}.json | `currency` | string | text | market data | market |
| /api/v1/fund/{ticker}.json | `holdings` | object | percent weight by ticker | issuer file or SEC filing, see source_layer | issuer |
| /api/v1/fund/{ticker}.json | `weekly` | array of number | decimal return per week | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `weeks_end` | string | date, YYYY-MM-DD | computed by TickerInside | own |
| /api/v1/fund/{ticker}.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json | `source` | string | text | TickerInside metadata | own |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `report_date` | string | date, YYYY-MM-DD | SEC filing | SEC |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `filed` | string | date, YYYY-MM-DD | SEC filing | SEC |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `filing_url` | string | text | SEC filing | SEC |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `net_assets` | integer | US dollars | SEC filing | SEC |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `multi_class` | boolean | true or false | SEC filing | SEC |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `stock_pct` | number | percent of net assets | SEC filing | SEC |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `unmapped_pct` | number | percent of net assets | SEC filing | SEC |
| /api/v1/fund/{ticker}.json, what a fund from SEC filings adds, from /api/v1/fund/smh.json | `abroad` | array of string | structure, see note | SEC filing | SEC |
| /api/v1/sec/{ticker}.json | `ticker` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json | `name` | string | text | market data | market |
| /api/v1/sec/{ticker}.json | `page_url` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json | `cite_as` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json | `cite_html` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `sector` | string | text | third-party sector labels from a public list of S&P 500 members; US Listed for other stocks | third-party |
| /api/v1/sec/{ticker}.json | `industry` | string | text | third-party sector labels from a public list of S&P 500 members | third-party |
| /api/v1/sec/{ticker}.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/sec/{ticker}.json | `page` | boolean | true or false | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json | `cap_b` | number | billions of US dollars | market data | market |
| /api/v1/sec/{ticker}.json | `pe` | number | ratio | market data | market |
| /api/v1/sec/{ticker}.json | `yield` | null | percent | market data | market |
| /api/v1/sec/{ticker}.json | `vol` | number | percent, annualised | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `beta` | number | ratio, against SPY's weekly returns | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `mdd3` | number | percent, negative | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `r1` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `r3` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `r5` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `last_close` | number | trading currency | market data | market |
| /api/v1/sec/{ticker}.json | `last_close_date` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/sec/{ticker}.json | `day_change_pct` | number | percent | market data | market |
| /api/v1/sec/{ticker}.json | `high_52w` | number | trading currency | market data | market |
| /api/v1/sec/{ticker}.json | `low_52w` | number | trading currency | market data | market |
| /api/v1/sec/{ticker}.json | `currency` | string | text | market data | market |
| /api/v1/sec/{ticker}.json | `calendar` | object | percent by calendar year | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `held_by` | integer | count | issuer files | issuer |
| /api/v1/sec/{ticker}.json | `heaviest` | [ticker, weight] | [fund, percent] | issuer files | issuer |
| /api/v1/sec/{ticker}.json | `held_by_sec_nport` | integer | count | SEC filings | SEC |
| /api/v1/sec/{ticker}.json | `holders` | array of [ticker, weight, date] | percent weight per fund | issuer files | issuer |
| /api/v1/sec/{ticker}.json | `holders_sec_nport` | array of [ticker, weight, date] | percent weight per fund | SEC filings | SEC |
| /api/v1/sec/{ticker}.json | `synthetic_exposure` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `left_out` | array of string | structure, see note | issuer files | issuer |
| /api/v1/sec/{ticker}.json | `same_code_abroad` | array of [key, name] | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `earlier_key_reads_as` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `etf_ownership` | object | object, its fields listed below | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `etf_holders_since_2019` | object | object: answer, quarters | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `holders_all` | array of [fund, weight, date, layer, rank, positions, value] | [fund, percent weight, date, layer, rank in the fund, count of positions, millions of US dollars] | issuer files and SEC filings, with market data for the net assets | issuer |
| /api/v1/sec/{ticker}.json | `rank_summary` | object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `top_by_value` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `membership` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `by_issuer` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `fee_per_1000` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `name_collision` | object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `answer` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `least_correlated` | array of [ticker, correlation, name] | [ticker, correlation coefficient, name] | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `most_correlated` | array of [ticker, correlation, name] | [ticker, correlation coefficient, name] | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `weekly` | array of number | decimal return per week | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `weeks_end` | string | date, YYYY-MM-DD | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json | `source` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `pct_lower_bound` | number | percent, rounded down to two decimals | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `basis` | string | text: company or class | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `company` | string | text | market data | market |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `shares_held` | integer | shares | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `shares_held_by_layer` | object | shares, by layer | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `shares_outstanding` | integer | shares | SEC XBRL cover | public |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `shares_outstanding_as_of` | string | date, YYYY-MM-DD | SEC XBRL cover | public |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `shares_outstanding_filing` | string | URL | SEC XBRL cover | public |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `funds_holding` | object | count, by layer | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `funds_counted` | object | count, by layer | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `funds_prorated` | integer | count | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `not_counted` | object | count of funds, by reason | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `rows_not_counted` | object | count of rows, by reason | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `holdings_dates` | object | dates, YYYY-MM-DD: oldest and newest | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `holdings_dates_by_layer` | object | dates, YYYY-MM-DD: oldest and newest, by layer | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `classes` | array of object | per class: shares, date, percent | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `refused` | string | text: a refusal code, listed in methods.json | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `refused_reason` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `held_back` | object | null, or text reason with counts and a date | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `method` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `method_url` | string | URL | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `cite_as` | string | text | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json, the etf_ownership object | `cite_html` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the rank_summary object | `funds` | integer | number, see note | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json, the rank_summary object | `top_holding_in` | integer | count | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the rank_summary object | `top10_in` | integer | count | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the rank_summary object | `funds_without_value` | integer | count | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the rank_summary object | `short_positions` | integer | count | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the rank_summary object | `by_layer` | object | structure, see note | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `fund` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `value_usd_m` | number | millions of US dollars | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `weight` | number | percent | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `holdings_as_of` | string | date, YYYY-MM-DD | issuer file or SEC filing | issuer |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `layer` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `net_assets_b` | number | billions of US dollars | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `net_assets_basis` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of top_by_value | `net_assets_as_of` | string | date, YYYY-MM-DD | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of membership | `fund` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of membership | `kind` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of membership | `category` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of membership | `held` | boolean | true or false | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of membership | `weight` | number | percent | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of membership | `rank_in_fund` | integer | rank, 1 the largest | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of membership | `positions` | integer | count | issuer file or SEC filing | issuer |
| /api/v1/sec/{ticker}.json, a line of membership | `holdings_as_of` | string | date, YYYY-MM-DD | issuer file or SEC filing | issuer |
| /api/v1/sec/{ticker}.json, a line of membership | `layer` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of by_issuer | `issuer` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of by_issuer | `funds` | integer | number, see note | TickerInside metadata | own |
| /api/v1/sec/{ticker}.json, a line of by_issuer | `value_usd_m` | number | millions of US dollars | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of by_issuer | `funds_without_value` | integer | count | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of by_issuer | `heaviest` | [ticker, weight] | [fund, percent] | issuer files | issuer |
| /api/v1/sec/{ticker}.json, a line of by_issuer | `largest` | array of number | [fund, millions of US dollars] | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of fee_per_1000 | `fund` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of fee_per_1000 | `fee_usd_per_1000` | number | US dollars a year per $1,000 of the stock held | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of fee_per_1000 | `expense_ratio` | number | percent of assets per year | SEC filing or market data | market |
| /api/v1/sec/{ticker}.json, a line of fee_per_1000 | `weight` | number | percent | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, a line of fee_per_1000 | `holdings_as_of` | string | date, YYYY-MM-DD | issuer file or SEC filing | issuer |
| /api/v1/sec/{ticker}.json, a line of fee_per_1000 | `layer` | string | text | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the name_collision object | `name` | string | text | market data | market |
| /api/v1/sec/{ticker}.json, the name_collision object | `count` | integer | count | computed by TickerInside | own |
| /api/v1/sec/{ticker}.json, the name_collision object | `funds` | array of object | structure, see note | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json | `pair` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/compare/{a}-vs-{b}.json | `holdings_as_of` | object | date, YYYY-MM-DD | issuer file or SEC filing | issuer |
| /api/v1/compare/{a}-vs-{b}.json | `overlap` | object | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json | `correlation` | object | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json | `funds` | object | structure, see note | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json | `page_url` | string | text | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json | `cite_as` | string | text | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json | `cite_html` | string | text | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json | `source` | string | text | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `by_weight` | number | percent | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `share_of_a` | number | percent | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `share_of_b` | number | percent | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `n_shared` | integer | count | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `n_a` | integer | count | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `n_b` | integer | count | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `top` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `only_a` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the overlap object | `only_b` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the correlation object | `c1y` | number | correlation coefficient | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the correlation object | `c3y` | number | correlation coefficient | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the correlation object | `c5y` | number | correlation coefficient | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the correlation object | `cov` | number | percent squared, annualised | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, the correlation object | `weeks` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `ticker` | string | text | TickerInside metadata | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `name` | string | text | market data | market |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `kind` | string | text | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `group` | string | text | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `vol` | number | percent, annualised | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `beta` | number | ratio, against SPY's weekly returns | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `r1` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `r3` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `r5` | number | percent, cumulative | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `mdd3` | number | percent, negative | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `cal` | object | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `er` | number | percent of assets per year | SEC filing or market data | market |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `yield` | number | percent | market data | market |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `aum_b` | number | billions of US dollars | market data | market |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `family` | string | text | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `cat` | string | text | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `nh` | integer | number, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `spark` | array of number | structure, see note | computed by TickerInside | own |
| /api/v1/compare/{a}-vs-{b}.json, a fund's summary, in funds | `px` | object | structure, see note | computed by TickerInside | own |
| /api/v1/funds.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/funds.json | `count` | integer | count | computed by TickerInside | own |
| /api/v1/funds.json | `with_a_page` | integer | count | computed by TickerInside | own |
| /api/v1/funds.json | `note` | string | text | TickerInside metadata | own |
| /api/v1/funds.json | `funds` | array of object | structure, see note | TickerInside metadata | own |
| /api/v1/funds.json | `sec_count` | integer | count | computed by TickerInside | own |
| /api/v1/funds.json | `sec_note` | string | text | TickerInside metadata | own |
| /api/v1/funds.json | `sec_funds` | array of object | structure, see note | SEC filings | SEC |
| /api/v1/funds.json | `sponsor_funds` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/funds.json | `prospectus_funds` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/funds.json | `bond_funds` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/funds.json | `multi_asset_funds` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/funds.json | `derivative_funds` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/funds.json | `trust_funds` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/funds.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/funds.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/holders.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/holders.json | `holdings_as_of` | object | date by fund, YYYY-MM-DD | issuer files | issuer |
| /api/v1/holders.json | `funds` | object | fund name by ticker | TickerInside metadata | own |
| /api/v1/holders.json | `securities` | integer | count or list, see type | issuer files | issuer |
| /api/v1/holders.json | `names` | object | company name by key | TickerInside metadata | own |
| /api/v1/holders.json | `note` | string | text | TickerInside metadata | own |
| /api/v1/holders.json | `holders` | object of arrays of [ticker, weight] | percent weight per fund | issuer files | issuer |
| /api/v1/holders.json | `aliases` | object | keys by old key | computed by TickerInside | own |
| /api/v1/holders.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/holders.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/holders.json | `source` | string | text | TickerInside metadata | own |
| /api/v1/holders/{c}.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/holders/{c}.json | `holdings_as_of` | object | date by fund, YYYY-MM-DD | issuer files | issuer |
| /api/v1/holders/{c}.json | `funds` | object | fund name by ticker | TickerInside metadata | own |
| /api/v1/holders/{c}.json | `facts` | object | name and figures per key, units as in a stock file | market data | market |
| /api/v1/holders/{c}.json | `holders` | object of arrays of [ticker, weight] | [fund, percent weight] per key | issuer files | issuer |
| /api/v1/holders/{c}.json | `holders_sec_nport` | object of arrays of [ticker, weight] | [fund, percent weight] per key | SEC filings | SEC |
| /api/v1/holders/{c}.json | `sec_nport_as_of` | object | date by fund, YYYY-MM-DD | SEC filings | SEC |
| /api/v1/holders/{c}.json | `aliases` | object | keys by old key | computed by TickerInside | own |
| /api/v1/holders/{c}.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/holders/{c}.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/securities.json | `as_of` | string | date, YYYY-MM-DD | market data | market |
| /api/v1/securities.json | `count` | integer | count | computed by TickerInside | own |
| /api/v1/securities.json | `note` | string | text | TickerInside metadata | own |
| /api/v1/securities.json | `securities` | array of [ticker, funds, weight, name, page, file] | count or list, see type | issuer files | issuer |
| /api/v1/securities.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/securities.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/ownership.json | `as_of` | string | date, YYYY-MM-DD | issuer files | issuer |
| /api/v1/ownership.json | `method` | string | text | TickerInside metadata | own |
| /api/v1/ownership.json | `method_url` | string | URL | TickerInside metadata | own |
| /api/v1/ownership.json | `count` | integer | count | computed by TickerInside | own |
| /api/v1/ownership.json | `note` | string | text | TickerInside metadata | own |
| /api/v1/ownership.json | `stocks` | array of [ticker, percent, funds, basis] | [ticker, percent, count of funds, basis: company or class] | computed by TickerInside | own |
| /api/v1/ownership.json | `refused` | object | count of stocks, by reason | computed by TickerInside | own |
| /api/v1/ownership.json | `refused_reasons` | object | text, by reason | computed by TickerInside | own |
| /api/v1/ownership.json | `top10_share` | object | percent, with the companies, counts and dates | computed by TickerInside | own |
| /api/v1/ownership.json | `most_widely_held` | array of [ticker, company, funds, percent, basis] | [ticker, company name, count of funds holding any class, percent, basis: company or class] | computed by TickerInside | own |
| /api/v1/ownership.json | `held_back` | object | null, or text reason with counts and a date | computed by TickerInside | own |
| /api/v1/ownership.json | `docs` | string | text | TickerInside metadata | own |
| /api/v1/ownership.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/ownership.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/ownership.json, the top10_share object | `pct` | number | percent, rounded to one decimal | computed by TickerInside | own |
| /api/v1/ownership.json, the top10_share object | `companies` | array of string | tickers | computed by TickerInside | own |
| /api/v1/ownership.json, the top10_share object | `funds` | integer | count | computed by TickerInside | own |
| /api/v1/ownership.json, the top10_share object | `funds_without_net_assets` | integer | count | computed by TickerInside | own |
| /api/v1/ownership.json, the top10_share object | `net_assets_dates` | object | dates, YYYY-MM-DD: oldest and newest | computed by TickerInside | own |
| /api/v1/methods.json | `note` | string | text | TickerInside metadata | own |
| /api/v1/methods.json | `methods` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/methods.json | `docs` | string | text | TickerInside metadata | own |
| /api/v1/methods.json | `license` | string | text | TickerInside metadata | own |
| /api/v1/methods.json | `attribution` | string | text | TickerInside metadata | own |
| /api/v1/methods.json, a method | `id` | string | text | computed by TickerInside | own |
| /api/v1/methods.json, a method | `name` | string | text | market data | market |
| /api/v1/methods.json, a method | `version` | integer | number | computed by TickerInside | own |
| /api/v1/methods.json, a method | `since` | string | date, YYYY-MM-DD | computed by TickerInside | own |
| /api/v1/methods.json, a method | `changes` | array of object | structure, see note | computed by TickerInside | own |
| /api/v1/methods.json, a method | `measures` | string | text | computed by TickerInside | own |
| /api/v1/methods.json, a method | `formula` | string | text | computed by TickerInside | own |
| /api/v1/methods.json, a method | `definitions` | object | structure, see note | computed by TickerInside | own |
| /api/v1/methods.json, a method | `rules` | array of string | structure, see note | computed by TickerInside | own |
| /api/v1/methods.json, a method | `not_counted` | object | count of funds, by reason | computed by TickerInside | own |
| /api/v1/methods.json, a method | `refusals` | object | structure, see note | computed by TickerInside | own |
| /api/v1/methods.json, a method | `vector_format` | string | text | computed by TickerInside | own |
| /api/v1/methods.json, a method | `vectors` | array of object | inputs with the output they give | computed by TickerInside | own |
| /api/v1/history.json | `as_of` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history.json | `since` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history.json | `count` | integer | count | archive of issuer files | history |
| /api/v1/history.json | `funds` | array of object | one entry per fund, fields below | archive of issuer files | history |
| /api/v1/history.json | `holdings_at` | string | URL template, or null | archive of issuer files | history |
| /api/v1/history.json | `note` | string | text | archive of issuer files | history |
| /api/v1/history.json | `docs` | string | text | archive of issuer files | history |
| /api/v1/history.json | `license` | string | text | archive of issuer files | history |
| /api/v1/history.json | `terms` | string | text | archive of issuer files | history |
| /api/v1/history.json | `attribution` | string | text | archive of issuer files | history |
| /api/v1/history.json, a fund entry | `t` | string | text | archive of issuer files | history |
| /api/v1/history.json, a fund entry | `first` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history.json, a fund entry | `last` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history.json, a fund entry | `file_dates` | integer | count | archive of issuer files | history |
| /api/v1/history.json, a fund entry | `cadence` | string | text: daily, monthly or irregular | archive of issuer files | history |
| /api/v1/history.json, a fund entry | `traded_pp_from` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history.json, a fund entry | `url` | string | URL | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `ticker` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `name` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `source_layer` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `key_scheme` | integer | number: 1 or 2 | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `first` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `last` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `file_dates` | integer | count | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `cadence` | string | text: daily, monthly or irregular | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `snapshots` | object | columns and rows, one row per file date | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `moved_threshold_pp` | number | percentage points | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `traded_min_pairs` | integer | count | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `traded_pairs` | integer | count | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `traded_pp_from` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `traded_pp_reason` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `changes` | array | one entry per step, fields below | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `overlap_history` | object | the ten closest funds, fields below | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `holdings_at` | string | URL template, or null | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `fund` | string | URL | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `cite_as` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `cite_html` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `docs` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `license` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `terms` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json | `attribution` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json, the snapshots object | `columns` | array of string | names | archive of issuer files | history |
| /api/v1/history/{ticker}.json, the snapshots object | `rows` | array of array | [date, count, percent, number, keys or null] | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `date` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `previous` | string | date, YYYY-MM-DD | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `entered` | array of [key, weight] | [key, percent weight] | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `exited` | array of [key, weight] | [key, percent weight in the previous file] | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `moved` | array of [key, before, after] | [key, percent before, percent after] | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `moved_below_threshold` | integer | count | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `names_turnover_pp` | number | percentage points | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `weights_moved_pp` | number | percentage points | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `traded_pp` | number | percentage points of assets | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `reverted` | array of string | keys | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `restated` | boolean | true or false | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `reason` | string | text | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `rekeyed` | array of [old key, array of key] | [old key, [keys now]] | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `market_added` | integer | count | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `coverage_added_pp` | number | percentage points | archive of issuer files | history |
| /api/v1/history/{ticker}.json, a step, in changes | `splits_seen` | array of string | keys | archive of issuer files | history |
| /api/v1/history/{ticker}.json, the overlap_history object | `with_top_funds_by_overlap` | integer | count | archive of issuer files | history |
| /api/v1/history/{ticker}.json, the overlap_history object | `series` | object of array of [date, overlap] | [date, percent overlap by weight] per fund | archive of issuer files | history |

## MCP tools

The server at https://tickerinside.com/mcp and the npm package tickerinside-mcp run the same 12 tools. Every tool only reads. Each line says when to call the tool and which to call instead; tools/list gives what each returns.

- `list_etfs`, Coverage and ETF search: Use this when the user asks whether a US ETF is covered, wants to find an ETF by name or ticker, or asks how many ETFs the data covers and how recent it is. Not for an ETF's holdings or figures (get_etf_holdings).
- `get_etf_holdings`, ETF holdings and profile: Use this when the user asks what a US ETF or mutual fund holds or its sectors, cost, size, returns and risk. Not for comparing ETFs (compare_etfs) or the ETFs holding a stock (find_etfs_holding_stock).
- `compare_etfs`, Overlap and risk of two ETFs: Use this when the user names exactly two US ETFs and asks how much they overlap, whether one duplicates the other, or how they differ in cost and risk. Not for three or more ETFs (get_etf_overlap_matrix).
- `get_etf_overlap_matrix`, Overlap across many ETFs: Use this when the user lists three to thirty US ETFs, often a portfolio, and asks which of them duplicate each other or whether the list is diversified across companies; two give one pair. Not for the companies underneath (get_etf_portfolio_lookthrough) or how ETFs move together (get_etf_portfolio_risk).
- `get_etf_portfolio_lookthrough`, Companies inside a portfolio: Use this when the user gives a portfolio of US ETFs and asks which companies they own, how much of one company they hold, or how concentrated it is. Not for duplicate ETFs (get_etf_overlap_matrix) or risk (get_etf_portfolio_risk).
- `get_etf_portfolio_risk`, Portfolio risk breakdown: Use this when the user gives a portfolio of US ETFs and asks where its risk comes from or how its ETFs move together. Not for the companies held (get_etf_portfolio_lookthrough).
- `find_etfs_holding_stock`, ETFs that hold a stock: Use this when the user asks which ETFs hold a stock, which ETF holds the most of it, how many ETFs hold it, or whether it is in VOO, SPY, IVV, QQQ, VTI or SCHD. Not for one stock's weight in another ETF (compare_stocks) or the share ETFs own (get_etf_ownership).
- `compare_stocks`, Stock comparison and weight in an ETF: Use this when the user asks how two US stocks compare on size, valuation, returns, risk or correlation, or what weight and rank one stock has inside one named ETF, for example META in QQQ. Not for comparing two ETFs (compare_etfs), or a company's business or products.
- `get_etf_ownership`, ETF ownership of a stock: Use this when the user asks how much of a US company ETFs own, or what share of its stock sits in ETFs. Not for the list of ETFs that hold the stock (find_etfs_holding_stock).
- `get_etf_holdings_history`, ETF holdings history: Use this when the user asks how a US ETF's holdings evolved over time, what it held in a past year or quarter, how often its holdings file changes, or how its overlap with its closest ETFs moved. Not for the lines one step added or dropped (get_etf_holdings_changes).
- `get_etf_holdings_changes`, ETF holdings changes: Use this when the user asks what a US ETF bought, sold, added or dropped, or how the weights of its holdings changed, recently or since a date. Not for an ETF's holdings on one date (get_etf_holdings) or its overlap over time (get_etf_holdings_history).
- `get_etf_flows`, ETF buying and selling: Use this when the user asks whether ETFs are buying or selling a stock, which stocks ETFs bought or sold the most, or which stocks entered or left an index fund. Not for which ETFs hold a stock (find_etfs_holding_stock) or one ETF's changes (get_etf_holdings_changes).

The 6 prompts each return one user message that asks its question in plain words and names the tool that answers it:

- `what_does_this_etf_hold` (ticker): get_etf_holdings
- `which_etfs_hold_this_stock` (ticker): find_etfs_holding_stock
- `do_my_etfs_overlap` (tickers): compare_etfs or get_etf_overlap_matrix
- `what_is_inside_my_etf_portfolio` (holdings): get_etf_portfolio_lookthrough
- `are_etfs_buying_this_stock` (ticker): get_etf_flows
- `does_this_etf_diversify_my_portfolio` (have, try): compare_etfs or get_etf_portfolio_risk or get_etf_holdings

## Citation rule

Every fund, stock and comparison file carries `cite_as`. Print it under any figure you quote. Credit TickerInside with a link to the page the figure comes from (cite_as gives it) wherever the medium allows a link, and by name where it does not. How you mark the link is up to you; `cite_html` is that link, ready to paste. Give `holdings_as_of` beside any holdings figure and `as_of` beside any price, return or risk figure. For VOO:

```text
TickerInside, Vanguard S&P 500 ETF (VOO), holdings from the issuer's file of 2026-08-31, https://tickerinside.com/etf/voo/, CC BY 4.0
```