Free ETF holdings API

Quickstart

One HTTPS request, with no key and no account. Every fund, stock and comparison file carries its dates and a citation line.

Copy for LLM·View as Markdown

Base URL

https://tickerinside.com/api/v1Copy

Authentication

None

No key, no account, no per-user quota

Format

JSON over HTTPS

UTF-8, CORS open to any origin

Updates

Weekday nights

Built from 22:00 UTC, due by 02:00 UTC; cached five minutes, 304 to If-None-Match

1. 1Request a file

   Ask which ETFs hold Nvidia. Tickers go in the path in lower case.

   ShellCopy

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

2. 2Read the answer

   holders lists the funds read from their issuers' own files, heaviest first, each 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: /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.

   Response, shortened200 · 76.7 KB

   {
     "ticker": "NVDA",
     "name": "Nvidia",
     "…": "24 more fields",
     "held_by": 160,
     "heaviest": ["GXPT", 19.88],
     "held_by_sec_nport": 587,
     "holders": [
       ["GXPT", 19.88, "2026-10-16"],
       ["IYW", 16.5999, "2026-10-15"],
       ["TOPT", 15.6462, "2026-10-15"],
       "… 157 more"
     ],
     "holders_sec_nport": [
       ["SMHX", 18.5624, "2026-06-30"],
       ["SMH", 17.5486, "2026-06-30"],
       "… 585 more"
     ],
     "…": "1 more field",
     "left_out": [],
     "…": "19 more fields"
   }
   

3. 3Show the date and the source

   Print cite_as under any figure you show: the dates in it are what let a reader check the figure. 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.

   cite_as, from /api/v1/sec/nvda.jsonCopy

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

Use it from a coding agent

One line each, for Claude Code, Codex, Cursor, Copilot, Gemini CLI and any agent that runs a command or speaks MCP. None needs a key.

Copy for LLM·View as Markdown

The whole reference as one text file is /llms-full.txt, and /llms.txt maps the site. This page as Markdown is /api/index.md, and each of its sections and endpoints is a file of its own, listed in /api/sections/index.md. Fetch the JSON with curl or fetch and parse it; a browsing tool that summarizes pages drops fields and dates.

Endpoints

Static JSON files under https://tickerinside.com/api/v1, and five answers computed from them when asked, read with GET. Each path leads to its fields in the field reference at the end of this page.

Copy for LLM·View as Markdown

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. Try it sends the request from this page to the live API and shows the start of the answer.

• GET /index.json

  What exists: every covered ticker, the coverage counts and the date of the data. Start here.

  index.json46.8 KBCopy for LLM·Markdown

• GET /funds.json

  Every fund, one line each: name, issuer, category, size, cost, position count and the address of its file.

  funds.json1.6 MBCopy for LLM·Markdown

• GET /universe.json

  The US-listed ETFs in Nasdaq Trader's symbol directory, how each is covered or why not yet, and the coverage measured against that list.

  universe.json453 KBCopy for LLM·Markdown

• 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 or AGTHX with its fund's holdings from its latest SEC Form N-PORT (kind mutual_fund), a bond fund such as PTTRX by issuer with its fixed income statistics, as a bond ETF's file gives them, a target-date fund such as VFIFX looked through to the stocks one dollar of it holds (look_through, and every one of them side by side on the target-date funds page), and VFIAX with the holdings of VOO, the ETF class of the same fund (share_class_of), never with the ETF's cost or price. /api/v1/mutual-funds.json lists them.

  voo.json11.1 KBCopy for LLM·Markdown

• GET /sec/{ticker}.json

  One stock (sec for security, not the SEC): 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.

  nvda.json76.7 KBCopy for LLM·Markdown

• GET /holders.json

  The reverse index of the 626 issuer files: every security their funds hold, and which of them hold it, in one file.

  holders.json3.9 MBCopy for LLM·Markdown

• 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.

  a.json640 KBCopy for LLM·Markdown

• GET /securities.json

  Every security the funds of those issuer files hold, with how many of them hold it and its largest weight.

  securities.json792 KBCopy for LLM·Markdown

• GET /identifiers.json

  Every fund and stock with a file: its FIGIs, its SEC CIK and, for a fund, its SEC series and class ids, which never change while a ticker may, with its exchange and asset type. /api/v1/identifiers.csv gives the same rows.

  identifiers.json1.3 MBCopy for LLM·Markdown

• 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.

  ownership.json93.5 KBCopy for LLM·Markdown

• GET /methods.json

  The methods of the ETF ownership figure, ti-ownership/1, of the ETF Ownership Index, ti-ownership-index/1, and of the overlap of two funds that the written comparisons give, ti-overlap/1, with their formulas, rules and test vectors.

  methods.json34.7 KBCopy for LLM·Markdown

• GET /ownership-index.json

  The ETF Ownership Index: each stock's share held by the covered US ETFs, at least, the funds counted and the share the three largest of them hold, then the market and sector lines weighted by market cap. Its CSV twin is /api/v1/ownership-index.csv, and the methodology has a worked example.

  ownership-index.jsonCopy for LLM·Markdown

• GET /ownership-index/history.json

  The index by market close, and each stock's change of ETF ownership over 5 and 20 market days, from the flows of the funds read daily. Its CSV twin is /api/v1/ownership-index/history.csv. Under the history terms.

  history.jsonCopy for LLM·Markdown

• GET /compare/{a}-vs-{b}.json

  A written comparison: ETF overlap measured three ways, and correlation over one, three and five years. Only the 15 pairs in index.json written_comparisons have one, 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.

  voo-vs-vti.json5.3 KBCopy for LLM·Markdown

• GET /overlap?funds={funds}

  The overlap of 2 to 10 funds, computed when asked with the code of the MCP tools, so the figures are theirs: two funds give the overlap by weight, each fund's share in common, the largest shared holdings and the correlation of weekly returns; three or more give every pair ranked. Two bond funds overlap by issuer, a fund that holds no shares is set aside with the reason. /api/v1/overlap.csv gives one row per pair.

  overlap?funds=VOO,QQQCopy for LLM·Markdown

• GET /lookthrough?portfolio={portfolio}

  The companies under a portfolio of funds, each fund with its weight or amount after a colon, or none for equal weights: each company's weight, its value and the funds it comes through, as the MCP tool get_etf_portfolio_lookthrough gives them. /api/v1/lookthrough.csv gives one row per company.

  lookthrough?portfolio=VOO:60,QQQ:40Copy for LLM·Markdown

• GET /batch?funds={funds}

  Up to 10 fund files in one answer, keyed by ticker, each exactly what /fund/ answers, with the tickers not covered and why.

  batch?funds=VOO,QQQ,VTICopy for LLM·Markdown

• GET /screen?holds={holds}

  The funds that pass a few filters: issuer, category, layer, expense_ratio_max, aum_min, and holds a stock with min_weight, sorted and paged with sort, limit and offset. /api/v1/screen.csv gives the page as rows.

  screen?holds=NVDA&min_weight=10Copy for LLM·Markdown

• GET /diversify?have={have}&try={try}

  For each fund of try, against the funds of have at their weights: its overlap by weight, the correlation of weekly returns on all weeks and on the weeks the funds held fell, its part in mega-cap tech, its sectors and countries as its fund file's breakdown gives them, and one sentence to quote, ranked by overlap, then correlation. A trust, a derivative-based or a bond fund counts in the correlation from its own weekly prices. /diversify/ with the same query renders the answer as a page.

  diversify?have=QQQ,SMH,IBIT&try=AVUV,VXUSCopy for LLM·Markdown

• GET /history.json

  Every fund with a holdings history, from its issuer's own files: the dates of its oldest and newest files, how many, and the address of its history. Under the history terms.

  history.json120 KBCopy for LLM·Markdown

• 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.

  spy.json15.0 KBCopy for LLM·Markdown

• 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, the index entries and exits, and the last 20 closes. Every security moved is in /api/v1/flows.csv, and the summary is a feed, /feeds/flows.xml. Under the history terms.

  flows.json49.5 KBCopy for LLM·Markdown

• GET /flows/{ticker}.json

  One security's flows: the funds adding and trimming it, the net change in shares and dollars, the funds with the largest changes and a series over the last 20 file days. As feeds: /feeds/stock/{ticker}.xml, and /feeds/fund/{ticker}.xml for one fund's changes.

  nvda.jsonCopy for LLM·Markdown

• GET /status.json

  The nightly report: when the build ran and the date of each layer of the data.

  status.jsonCopy for LLM·Markdown

• GET /uptime.json

  Live checks of the pages, the API and the MCP server, every five minutes.

  uptime.jsonCopy for LLM·Markdown

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. Any pair without a written comparison is measured from its two fund files, as the overlap example does.

Errors and redirects

The HTTP status is the answer, and every answer under /api/ is open to any origin. A 404 carries a short JSON body whose reason and follow-up address say what to request next, and a 400 of a computed answer one whose reason and parameter say what to fix.

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, so a client or a proxy may keep it for five minutes and then check it with the ETag. uptime.json is computed when asked and kept for one minute. The five computed answers carry the same Cache-Control and an ETag of the query and the deploy, and the edge cache keeps each for up to a day, so the same query asked again is not computed again. Every answer also 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. Three computed answers have one too, with the path in .csv or format=csv: /api/v1/overlap.csv?funds=VOO,QQQ,SCHD, one row per pair with both holdings dates; /api/v1/lookthrough.csv?portfolio=VOO:60,QQQ:40, one row per company with the funds it comes through and their dates; and /api/v1/screen.csv, one row per fund. Google Sheets reads them with IMPORTDATA, Excel and Power BI from the web: ETF holdings in Excel and Google Sheets 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 in eleven languages, then three recipes for other jobs. In cURL, Python, Python (tickerinside), JavaScript, R, Java, C#, C++ and Go, each example shows what it printed against the live API on the day it was recorded. The tab of any other language says how it was checked, or that it has not run yet.

Copy for LLM·View as Markdown

Six use cases, each a page with a live example and code that runs against each night's build before it is published: ETF holdings API, ETF overlap API, Which ETFs hold a stock, by API, ETF holdings history API, Portfolio exposure API and ETF screener API. All of them in one file for agents: /api/sections/use-cases.md.

• A fund's holdings
• Which ETFs hold a stock
• ETF overlap
• ETF ownership
• Every fund
• Holdings as CSV
• Correlation
• Files with curl

Pick a language in one example and every example on the page shows it. cURL, Python and JavaScript are printed here; the other languages load when their tab is picked, and every example is also a plain file under /api/examples/, which its tab links. Each 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) tab uses the client on PyPI, tickerinside, version 0.5.0 of 2026-10-13: pip install tickerinside. It needs only the standard library; with pandas installed, every result also has a .df DataFrame.

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'

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

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"])

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

// 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);

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 -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'

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

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"])

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

// 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);

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

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'

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

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"])

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

// 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);

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 -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'

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

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"])

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

// 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);
}

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 -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)")'

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

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"])

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

// 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}`);

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

Recipes for other jobs

Each output shown under a recipe is what it prints on the files of 2026-10-16. The Python recipes share one helper. Paste it once, then any recipe below it. 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.

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)

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))

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

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))

[[1.   0.95 0.57 0.92]
 [0.95 1.   0.36 0.97]
 [0.57 0.36 1.   0.33]
 [0.92 0.97 0.33 1.  ]]

# 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

The same data as twelve read-only tools, served by a remote MCP server with nothing to install and no key.

Copy for LLM·View as Markdown

Server URL

https://tickerinside.com/mcpCopy

Transport and access

Streamable HTTP, no authentication

Read-only tools over the same files as this API

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

The twelve tools

The setup for any assistant, with a prompt to paste, is on the assistant page.

Where the data comes from

Two layers of holdings, kept apart and dated in every file, and end of day prices for the returns.

Copy for LLM·View as Markdown

Prices and weekly returns

End of day prices through 2026-10-16 give weekly total returns over the same 156 weeks, the series behind every return, risk and correlation figure. 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. Prices refresh after the US close on trading days.

Identifiers, under identifiers in each fund and stock file and in /api/v1/identifiers.json: FIGIs from OpenFIGI, asked by ticker, in the public domain under its terms; the CIK and a fund's series and class ids from the SEC's ticker files; the listing exchange from Nasdaq Trader's symbol directory.

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. 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: how many funds each source covers, the median age of their holdings, and the share dated within 7 and within 35 days.

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 key written with Yahoo's suffix for the exchange, 005930.KS or 0700.HK, is redirected to the key here, 005930.KR or 700.HK, and the MCP tools read it the same way; a suffix that is also a country code here (.SA, .CO, .BR) keeps its meaning here.
• 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.

Fixed income funds

The layers below have files of their own under /api/v1/etf/{ticker}.json, with no holdings and no positions. /api/v1/fund/{ticker}.json answers for each of their funds too, in the shape of the stock layers' files, built from that file: holdings maps the stocks and funds it holds outright by ticker, and its other lines under a key in lower case, a bond line as its issuer, coupon and maturity. holdings_kind says what the map holds and listed_pct how much of net assets it shows. A map is empty, with listed_pct 0, when the file lists no holding line by line: a derivative-based fund that holds no stock outright, whose Treasury bills, money market funds and repurchase agreements are in its composition by kind, a pool of futures, or a fund known from its prospectus only. positions counts the keys of the map, and filing_lines or file_lines the lines of the filing or the file. Every field of the /etf/ file follows. index.json says where each ticker is: tickers and tickers_sec are the stock layers, tickers_derivative, tickers_trust, tickers_bond, tickers_multi_asset, tickers_sponsor and tickers_prospectus the others.

Bond, credit, mortgage, Treasury and municipal ETFs are read from the same filings. A bond has no ticker and no CUSIP or ISIN is published, so a fixed income fund's file (source_layer sec_nport_bonds) lists lines by issuer name, kind, coupon and maturity, with the weight of each, and fixed_income gives the average coupon and maturity, the duration, the weight by maturity and by country, and the issuers. The largest funds have over ten thousand lines: the file lists the largest 200 and counts every line in its totals. Mortgage pools are summed by issuer, coupon and year of maturity. Average maturity counts a pool at its final maturity, and duration is the fund's own interest rate risk figure, which filers compute in their own way.

Two fixed income funds overlap by issuer: the smaller weight of each issuer both hold, summed. It is issuer overlap, never mixed with overlap by shares, and the MCP tool compare_etfs gives it. Their answers under /fund/ also overlap line by line, since the same bond filed under the same issuer name has the same key in both.

Multi-asset funds

A fund of funds, or an allocation, target date, buffer or income fund, has a file (source_layer sec_nport_multi_asset) with held_outright by ticker, composition and lines by name. It is in no holder list and no overlap.

Derivative-based funds

Leveraged, inverse, option income and buffer ETFs are bets on a market made through swaps, futures and options, so their stock rows alone say little. They are read from the same SEC filings, and their fund files (source_layer sec_nport_derivatives) keep the two apart. held_outright is what the fund holds outright, in percent of net assets, and composition adds its Treasury bills, money market funds and repurchase agreements. Its swaps, futures and options are in derivatives and underlyings, as notional exposure in percent of net assets, long or short, with the instrument: TQQQ reads about 227% in swaps and 16% in futures on the Nasdaq-100 Index, all long, beside the 58% it holds in stocks.

Notional exposure is not shares held. It is never in a holder count, in holders_all or in the ownership ledger. A stock's file lists the funds that reference it under synthetic_exposure, apart from its holders, so a question about which ETFs give exposure to NVDA can include NVDX and NVDY without counting them as holders. The size is the contract size the filing states. Where a filing gives none in dollars (T-Rex's NVDX writes its contract counts where the dollars belong), the leg has no notional_pct and the file says so. An option's notional is its strike times the shares it covers, and a written option is a short position in the option, not in the stock. None of these funds has a page.

Trusts and commodity pools

A physical gold trust, a bitcoin trust, a currency trust and a commodity pool are ETFs by any reader's count, and none files Form N-PORT. Their fund files (source_layer trust_filings) say what the fund holds, from the fund's own SEC filing, which the file names with its form and dates: a trust whose only investment is one asset lists it at 100, a trust of several assets lists them without a split, and a pool lists the futures it invests in as futures exposure, with no notional because its filings give no single one. There is no held_outright, since no share of any company is held through them. Each entry was checked against the filing before it was written, and a fund whose filing does not say what it holds is not served.

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.

The universe and its coverage

The universe is the list of US-listed ETFs in Nasdaq Trader's symbol directory, refreshed every weekday night and kept as it was when the download fails. US ETFs in numbers prints its counts with the kinds, categories and costs of the listed ETFs. /api/v1/universe.json lists each one with its name, the layer of fund files that covers it or the reason it does not yet, and the coverage is measured there over the funds only: an exchange-traded note is a debt of the bank that issues it, holds nothing, and is listed as a note, told from a fund by its name (ETN, ETRACS, iPath, X-Links, unless the name also says ETF). 5,423 of the 5,733 US-listed ETFs in Nasdaq Trader's symbol directory of 2026-10-16 have holdings here (94.6%), and 307 more have a file from their prospectus, with the objective it states and no holdings. The same block is in index.json and status.json. Only holdings files count as coverage; a prospectus file counts as a file. That each ETF of the directory has a file is said only when none lacks one, with how many have holdings and the stated objective. The share of assets is measured from holdings files alone.

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. The method, with its formula and test vectors, is /api/v1/methods.json, and every figure names it: ti-ownership/1. The highest figures are listed on the ETF ownership page, with their shares held, shares outstanding and dates.

Holdings history

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

Copy for LLM·View as Markdown

The archive began on 2026-09-03 and keeps one snapshot per fund and file date: 17,555 so far. For the others, the first file is dated between 2026-09-01 and 2026-09-03 for 511 funds (SPY: 2026-09-02) and on 2026-09-22 or later for 122. /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.

/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, list every report a US ETF listed today has filed with the SEC on Form N-PORT since the end of 2019, one for the last month of each of its fiscal quarters: its date, its filing on EDGAR, its position count, its top 10 weight and its ten largest positions, each company keyed by its ticker today (Facebook's rows of 2019 read META). /api/v1/quarterly.json lists the funds, each with its first and last report. They come from the SEC's public data sets and are under CC BY 4.0 like the rest of the API. A commodity trust (GLD) files no Form N-PORT and a unit investment trust (SPY, DIA) files it without a series, which this history does not read yet: both answer 404 with reason not_in_sec_history.

Holdings at a date, /api/v1/history/{ticker}/{date}.json, give every position of the fund's latest quarterly report on or before the date: holdings_as_of is the report's date and requested_date the date asked for. A date before the first report answers 404 with reason before_first_report and first_report, a fund that files no report holdings_at_date_not_enabled with the address of its file by file history, and a malformed date invalid_date.

Private companies held by US funds, on the private companies page and in /api/v1/private-companies.json with its CSV twin /api/v1/private-companies.csv: each company that is not listed and that two US mutual funds, ETFs or closed-end funds or more hold, from their latest SEC Form N-PORT, with the number of funds and the value they put on it. /api/v1/private-companies/{slug}.json lists each fund holding one, its stake, its shares, the value per share it reports and its filing, and the company's history by quarter since 2019. Under CC BY 4.0.

Daily ETF flows, on the ETF flows page and in /api/v1/etf-flows.json with its CSV twin /api/v1/etf-flows.csv: how much money went into and out of each ETF read daily on the latest complete market close, its net creations and redemptions in dollars, measured from its holdings (the value of what it bought less what it sold, and its own growth on its net assets, published when the two agree within 10%), with the largest inflows and outflows, the last five closes, the sums by issuer and by category, what the same ETFs bought and sold, and each close's totals. /api/v1/etf-flows/series.json gives every ETF's flow on each of the last 20 closes, and /feeds/etf-flows.xml is one item per close. Under the history terms.

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.

Cite this data

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

Copy for LLM·View as Markdown

TickerInside, Vanguard S&P 500 ETF (VOO), holdings from SEC Form N-PORT for the period ended 2026-06-30, filed 2026-08-28, https://tickerinside.com/etf/voo/, CC BY 4.0

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

Data: <a href="https://tickerinside.com">TickerInside</a> (CC BY 4.0)

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 below.

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

@misc{tickerinside_etf_holdings_20261016,
  author       = {{TickerInside}},
  title        = {{US ETF holdings, data through 2026-10-16}},
  year         = {2026},
  howpublished = {\url{https://tickerinside.com/}},
  note         = {Licence: CC BY 4.0}
}

The attribution kit gives each of these lines as text, Markdown, HTML, a Jupyter notebook cell, BibTeX, CSL-JSON and one sentence for an AI answer, for the data as a whole, a fund, a stock and a computed answer.

Licence and fair use

CC BY 4.0 for the current data, with no key and no per-user quota.

Copy for LLM·View as Markdown

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, with terms of their own.

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

There is no key, no account and no per-user quota. The terms of service apply to the API and the MCP server as to the site.

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). It shows which files people depend on and whom to tell before anything changes.

A missing field

Write to contact@tickerinside.com. What to include and how long an answer takes are on the support page.

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

Written by every nightly build, and checked every five minutes.

Copy for LLM·View as Markdown

Data through

2026-10-16

Prices and the newest issuer files

Last build

2026-10-17

Next build due

2026-10-20

By 02:00 UTC

Issuer files

626 of 626

Under 35 days old

Every build writes /api/v1/status.json: when it ran, the date of each layer of the data, the funds still served from an older file and why, the pages it dated as modified, and the versions of the API and the MCP server. A build runs every weekday night after 22:00 UTC and is due by 02:00 UTC the next morning.

Every five minutes the Worker that serves the site requests a fund page, the API index and an MCP handshake through the public address, and reads that report. What it saw is at /api/v1/uptime.json: each check's state, its share of passed checks over 24 hours, 7, 30 and 90 days, and the incidents, which open after two failed checks in a row. The checks run on Cloudflare like the site, so an outage of Cloudflare itself shows as checks missing, never counted as up.

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 68 ms on the last full day.

The status page draws both files: a bar of 90 days for each check, the incidents day by day and what the latest build did, with an Atom feed of the incidents.

Privacy

What the API, the MCP server, the files for agents and the pages record, and what they never record.

Copy for LLM·View as Markdown

Each request under /api/, this page and /api/files/ included, to /mcp, to the A2A agent at /a2a, to a feed under /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 the time of the record. The home page, the fund pages under /etf/, the stock pages under /stock/, the assistant page under /agent/, the ETF ownership page at /etf-ownership/, the ETF flows page at /etf-flows/, the pages under /private-companies/, /diversify/ and /xray/, by their path and never their query, write the same record in three cases only: an assistant fetching one of them for a person who asked it something (ChatGPT-User, Claude-User, Perplexity-User, MistralAI-User and DuckAssistBot); a visitor arriving on one of them from an answer engine, by a link marked utm_source=chatgpt.com or with a Referer from chatgpt.com, copilot.microsoft.com, bing.com, perplexity.ai, claude.ai, gemini.google.com, search.brave.com, duckduckgo.com or chat.mistral.ai; and any program asking for one of them as Markdown, with an Accept header that ranks text/markdown above text/html, as Claude Code and OpenCode send, which gets the page's Markdown version. Any other visit to a page writes nothing here. A request redirected with a 301, such as one with an upper case ticker, writes none: only the request it leads to is recorded.

The caller code changes every day, so it counts distinct callers within a day and cannot follow anyone from one day to the next. No IP address is stored and no cookie is set. An MCP tool call records the tool's name and, from the arguments that name a fund or a stock, up to eight values shaped like a ticker: one to twelve letters, digits and dots with at least one letter, a dash between two parts read as a dot. Nothing else of its arguments is recorded: a portfolio given to get_etf_portfolio_lookthrough or to /api/v1/lookthrough gives its tickers, never its weights or amounts, and a search query, digits alone or a value with a space is never kept. The answer of /api/v1/lookthrough, which repeats the weights, is kept in Cloudflare's edge cache for up to a day under its query, and served only to the same query. A word passed where a ticker goes, such as apple, is kept as APPLE, since nothing checks it against the list of tickers. The Worker's own status checks are not recorded, and its Workers request logs are turned off, so no log of each request's headers is kept beside these records.

Analytics Engine keeps these records for three months, and they are not sold or shared. Pages also count visits with Simple Analytics, which sets no cookie. The privacy policy says the same for every part of the service, with who processes the records and how to ask for yours. Questions: contact@tickerinside.com.

Versioning and machine-readable files

The version is in the path, and inside v1 fields are added, never removed or retyped.

Copy for LLM·View as Markdown

Fields are added as people ask for them. Every change to the site and its data is dated on the What changed page, and the nightly report gives the versions in use. The data contract says what v1 promises and how a program checks it: every build writes a manifest with the sha256 of every file under /api/v1/, the changes and deprecations are files a program reads, corrections are recorded in a registry with what the files said before and say since, and every 404 gives a reason code. The state of the service is on the status page.

Field reference

Every field of the files listed above, typed, with examples from the files of 2026-10-16 and, for uptime.json, from simulated checks. A type that says or null marks a field that can be null, which means missing, never zero.

Copy for LLM·View as Markdown

Words used here

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).

{
  "as_of": "2026-10-16",
  "coverage": {"funds": 626, "securities_held": 16724, "…": "1 more field", "sec_nport": 2049, "sec_nport_periods": {"oldest": "2026-01-31", "newest": "2026-08-31"}, "…": "13 more fields"},
  "…": "1 more field",
  "tickers": ["AAXJ", "ACHP", "ACWI", "… 623 more"],
  "tickers_sec": ["AAAA", "AADR", "AAEQ", "… 2,046 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"
}

{
  "ticker": "VOO",
  "…": "5 more fields",
  "source_layer": "sec_nport",
  "…": "1 more field",
  "as_of": "2026-10-16",
  "holdings_as_of": "2026-06-30",
  "…": "33 more fields",
  "holdings": {"NVDA": 7.5142, "AAPL": 6.59, "MSFT": 4.2966, "…": "501 more"},
  "weekly": [-0.025, 0.0586, 0.0136, "… 153 more"],
  "weeks_end": "2026-10-16",
  "…": "3 more fields"
}

{
  "ticker": "NVDA",
  "…": "25 more fields",
  "held_by": 160,
  "heaviest": ["GXPT", 19.88],
  "held_by_sec_nport": 587,
  "holders": [["GXPT", 19.88, "2026-10-16"], ["IYW", 16.5999, "2026-10-15"], "… 158 more"],
  "holders_sec_nport": [["SMHX", 18.5624, "2026-06-30"], "… 586 more"],
  "…": "1 more field",
  "left_out": [],
  "…": "2 more fields",
  "etf_ownership": {"pct_lower_bound": 7.56, "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-16"}, "…": "9 more fields"},
  "…": "11 more fields",
  "weekly": [-0.0214, 0.1112, 0.074, "… 153 more"],
  "…": "4 more fields"
}

{
  "pair": ["VOO", "VTI"],
  "…": "1 more field",
  "holdings_as_of": {"VOO": "2026-06-30", "VTI": "2026-06-30"},
  "overlap": {"by_weight": 88.1, "share_of_a": 99.9, "share_of_b": 88.3, "n_shared": 502, "…": "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 from VOO's SEC Form N-PORT for the period ended 2026-06-30, filed 2026-08-28, and VTI's SEC Form N-PORT for the period ended 2026-06-30, filed 2026-08-28, https://tickerinside.com/compare/voo-vs-vti/, CC BY 4.0",
  "…": "4 more fields"
}

{
  "kind": "pair",
  "…": "2 more fields",
  "pair": ["VOO", "QQQ"],
  "…": "1 more field",
  "holdings_as_of": {"VOO": "2026-08-31", "QQQ": "2026-10-08"},
  "…": "1 more field",
  "overlap": {"by_weight": 53.9, "share_of_a": 54, "share_of_b": 92.9, "companies_in_both": 85, "…": "2 more fields", "largest_shared": [{"ticker": "NVDA", "in_a": 8.09, "in_b": 8.33, "counted": 8.09}, {"ticker": "AAPL", "in_a": 7.04, "in_b": 7.45, "counted": 7.04}, "… 13 more"]},
  "correlation_3y": 0.95,
  "…": "1 more field",
  "weeks_used": 156,
  "…": "7 more fields"
}

{
  "…": "2 more fields",
  "priced": true,
  "…": "3 more fields",
  "funds": 2,
  "distinct_companies": 518,
  "top_10_weight_pct": 41.1,
  "…": "1 more field",
  "holdings_as_of": {"VOO": "2026-08-31", "QQQ": "2026-10-08"},
  "…": "1 more field",
  "companies": [{"ticker": "NVDA", "weight_pct": 8.189, "weight_pct_2dp": 8.19, "through": [{"fund": "VOO", "weight_pct": 4.8556}, {"fund": "QQQ", "weight_pct": 3.3337}], "value": 8.19}, "… 2 more"],
  "…": "5 more fields"
}

{
  "asked": ["VOO", "QQQ", "NVDA"],
  "found": 2,
  "not_covered": [{"error": "not_covered", "reason": "has_security_file", "ticker": "NVDA", "…": "1 more field", "security": "https://tickerinside.com/api/v1/sec/nvda.json"}],
  "funds": {"VOO": {"ticker": "VOO", "…": "8 more fields", "holdings_as_of": "2026-08-31", "…": "25 more fields", "holdings": {"NVDA": 8.0927, "AAPL": 7.0432, "…": "1 more"}, "…": "5 more fields"}},
  "…": "3 more fields"
}

{
  "…": "1 more field",
  "filters": {"holds": "NVDA", "min_weight": 15},
  "sort": "weight",
  "total": 29,
  "…": "2 more fields",
  "count": 3,
  "funds": [{"ticker": "GXPT", "name": "Global X PureCap℠ MSCI Information Technology ETF", "layer": "issuer_files", "issuer": "Global X", "category": "Technology", "category_id": "technology", "expense_ratio": 0.15, "aum_b": 0.1, "net_assets": null, "positions": 85, "report_date": null, "weight_pct": 19.89, "holdings_as_of": "2026-10-09", "holdings_source": "issuer file", "fund_file": "https://tickerinside.com/api/v1/fund/gxpt.json", "page_url": null}, "… 2 more"],
  "next": "https://tickerinside.com/api/v1/screen?holds=NVDA&min_weight=15&sort=weight&limit=3&offset=3",
  "…": "4 more fields"
}