# Field reference A section of the TickerInside API reference, https://tickerinside.com/api/#reference, with data through 2026-10-16. Contents of the reference, each section and endpoint as a file: https://tickerinside.com/api/sections/index.md. The whole reference as Markdown: https://tickerinside.com/api/index.md ## 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). ## 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-16. ## 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-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" } ``` - `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": "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` (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. - `identifiers` (object): FIGI and SEC ids: /api/v1/identifiers.json. - `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` (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` (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. - `flows` (object): For a fund read daily from its issuer's files, its net creations and redemptions in dollars, measured from its own holdings files (/etf-flows/): the close (date), flow_usd and flow_pct_of_assets, null with status not_measured when the two measures of it disagree, the close compared with (previous_close), the last closes' net (last_closes), each recent close's flow (series, [close, dollars or null]) and a sentence (text), with the page, the method and the terms. Absent for any other fund. - `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. What the four other layers add, in /api/v1/etf/{ticker}.json: - `derivative_positions` (integer): The derivative positions the filing lists, before the legs roll them up. - `held_outright` (object): What the fund holds outright: a map of ticker to percent of net assets, never its contracts (see derivatives). - `summary` (string): One sentence to quote: what the fund held, and for a trust the filing that says so. - `composition` (array of object): What the fund holds, as [{kind, label, pct}] in percent of net assets, largest first. kind is what the filing classes each line as: stocks, treasury_bills, treasury_notes_and_bonds, agency_debt, agency_mortgage_pools, corporate_bonds, municipal_bonds, money_market_funds, repurchase_agreements and the like. A trust lists its asset, pct 100.0 when it is the only investment and null where the filing gives no split. - `derivatives` (array of object): Swaps, futures and options, one leg per instrument, underlying and direction: instrument, description, underlying or underlying_ticker, underlying_kind, direction (the fund's side; a written option is short), notional_pct (the size the filing states, in percent of net assets; null when it gives none in dollars, always for a pool; an option's is strike times shares), value_pct, positions, option_type, option_side, expires_first, expires_last. - `underlyings` (array of object): The legs rolled up by underlying: long_pct and short_pct of swaps and futures, options by kind and side, instruments, net_pct, complete. - `exposure` (object): stocks_pct; swaps_futures_long_pct and swaps_futures_short_pct; options_notional_pct; complete; long_exposure_pct, stocks plus long swaps and futures when the fund has no short leg or option and every size is stated (TQQQ: about 300), else null. - `exposure_notes` (array): Caveats about the sizes, in words. - `structure` (string): The kind of trust or pool. - `source_form` (string): The SEC form the description was checked against. - `target` (null): The daily multiple a geared pool seeks (2x, -2x); null otherwise. - `filing_lines` (integer): The lines the filing has, for a fixed income or multi-asset fund: a count, not holdings. - `fixed_income` (object): A fixed income fund's figures, over every line of its filing: average_coupon_pct, average_maturity_years (a mortgage pool counts at its final maturity), duration_years (from the fund's own interest rate risk figures, null when it gives none), debt_pct, by_maturity, by_country and issuers [{issuer, key, pct, lines}], largest first, with issuers_total and issuers_shown_pct. Issuer overlap: the sum over shared key of the smaller pct. - `lines` (array of object): The largest lines of the filing by name, with no identifier: issuer, kind, coupon_pct, maturity (a date, or the year of a group of mortgage pools), pct, count of filing lines it stands for and, for an ETF this API covers, ticker. - `notes` (array of string): Caveats about the lines, in words. In a sponsor file, also how its weights are read (swap and futures weights are the sponsor's own, as notional in percent of net assets). - `sponsor` (string or null): The sponsor whose site was read; in a prospectus file, its adviser. - `source_url` (string): The address read. - `file_date` (string): The date of the sponsor's file. - `date_from` (string): file, page or read. - `read_on` (string): The day it was read. - `served_from_earlier_file` (boolean): True when an earlier night's file is kept. - `file_lines` (integer): Rows in the sponsor's file. - `lines_total` (integer): Lines not keyed and not a contract. - `form` (string): 497K, 497, 485BPOS or 485APOS. - `registrant` (string or null): The filing trust, or null. - `objective` (string): The objective, quoted (at most 400 characters). - `objective_is_quoted` (boolean): Always true. - `objective_cut` (boolean): True when cut, ending in three dots. - `stated_target` (null): The daily multiple and reference the prospectus states, or null. - `index` (string or null): The index it tracks, or null. - `expense_ratio_pct` (number or null): Expenses in percent, after a waiver; null if not read. - `inception_date` (null): The start date it states, or null. - `holdings_note` (string): Says its first holdings filing replaces this file. 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": 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" } ``` - `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". - `identifiers` (object): FIGI and SEC ids: /api/v1/identifiers.json. - `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: 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, 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-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" } ``` - `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` (null): Trailing twelve month distribution yield, as a percentage, or null. - `aum_b` (null): 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. ## Overlap of funds, computed: `/api/v1/overlap?funds={funds}` The overlap of the funds in funds, a list separated by commas, computed when asked with the code of the MCP tools compare_etfs and get_etf_overlap_matrix, so the figures are theirs. Two funds give the pair: the overlap by weight, each fund's share held in common, the largest shared holdings, the correlation of weekly returns and each fund's cost and risk (kind pair). Three or more give every pair ranked by overlap by weight (kind matrix). Two fixed income funds overlap by issuer; a fund that holds no shares is set aside with the reason, and a ticker not covered is skipped, or answers 404 in a pair. A fund asked for under the ticker it had before it was renamed is read under its new ticker, which renamed gives. format=csv, or /api/v1/overlap.csv, gives one row per pair. 2 to 10 funds. The files read weigh at most 64 KB for two funds and 58 KB for three or more, a file of the other layers a third of its size, and the pairs compare at most 2,600 holdings, each pair the holdings of the fund that holds fewer. ```json { "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" } ``` - `kind` (string): pair for two funds, matrix for three or more: which of the two shapes the answer has. - `page_url` (string or null): The web page whose HTML, as the server sends it, prints the answer's figure, so that it reads without JavaScript: for a pair, its written comparison when there is one, else its "Does it diversify me?" answer within that answer's limits; for three funds or more, the x-ray the site wrote of the same funds; for a look-through, the x-ray the site wrote of the portfolio at the same weights (listed under pages in /og/answers.json), or for one fund, its page. Null where no page prints the figure yet: any other overlap of three funds or more or look-through of two funds or more, a pair past those limits, a pair of bond funds. - `share_url` (string): The address whose HTML reproduces the whole answer on the site: for a pair, its "Does it diversify me?" answer within that answer's limits; for three funds or more and for a portfolio, the x-ray the site wrote of the same funds (listed under pages in /og/answers.json), each weight in percent to 0.01 point and never an amount, in the order of the funds the site wrote it in. Absent where no page prints the answer. - `pair` (array of string): The two funds, upper case, in the order asked. - `prices_as_of` (string or null): The price date of the figures read from weekly returns. Null when no fund has prices. - `holdings_as_of` (object): Each fund's holdings date, by ticker: the date of its issuer file, or the quarter end its SEC filing describes. - `holdings_source` (object): Each fund's source, by ticker: issuer file, SEC Form N-PORT, trust's own SEC filing, sponsor's own holdings file, or prospectus, no holdings yet. - `overlap` (object): For two funds holding shares, in percent: by_weight, the sum over the companies both hold of the smaller of their two weights; share_of_a and share_of_b, the part of each fund in companies the other holds too; companies_in_both, the holdings both have, counted by ticker (GOOGL and GOOG count as two), positions_a and positions_b; and largest_shared, the 15 largest shared holdings with each weight and the smaller one counted. A ticker the two hold for two different companies is left out of every figure and listed in same_ticker_two_companies, with same_ticker_note. - `overlap_kind` (string): issuer when the figures are an overlap by issuer, of fixed income funds. Absent otherwise. - `issuer_overlap` (object): For two fixed income funds: the overlap by issuer, the smaller weight of each issuer both hold summed (by_weight), the share of each, issuers_in_both, the issuers compared and the largest shared and unshared ones. Never mixed with the overlap by shares. - `correlation_3y` (number or null): The correlation of the two funds' weekly returns over up to three years, on the weeks both have. Null under 52 such weeks. - `covariance_annualised_pct2` (number or null): The annualised covariance of the same returns, in percent squared. Null with correlation_3y. - `weeks_used` (integer or null): How many weeks the two figures above read. Null when they are. - `funds` (object or null): Each fund by ticker: name, expense_ratio_pct, return_3y_pct, volatility_pct, worst_fall_3y_pct, beta_vs_sp500 (three years, from its file), beta_vs_sp500_1y (the last 52 weeks against SPY's) and positions; a fixed income fund's average coupon, maturity and duration. Null where the data has no figure. - `how_to_quote` (string): How to quote the figures: which measure, with the holdings dates. - `covered` (boolean): true when the funds are covered but the answer has no figures (see comparable or computed). - `comparable` (boolean): false when a fund of the two holds no shares that can be overlapped (see not_comparable). Absent when the figures are given. - `not_comparable` (array of object): The funds set aside, each with why and the address of its file (fund_file): a leveraged, inverse or other derivative-based fund, a trust or pool, a multi-asset, sponsor-file or prospectus-only fund, or a bond fund beside a stock fund. - `renamed` (object): Each ticker asked that a fund had before it was renamed, with its ticker now, under which the answer reads and names it. Absent when there is none. - `source` (object): The files the answer is computed from: each fund's page_url, null without a page, api_url, holdings_source and, for a fund from a filing, filing_url; benchmark_url, SPY's file, when a one-year beta is computed; license; and cite_as, the line to print under a figure. - `note` (string): Measurement, not investment advice. - `license` (string): The licence the data is published under. - `attribution` (string): How to credit the data: a link to the page of a fund the figure comes from, or to this address, where the medium allows one, the name where it does not. - `docs` (string): The reference of this endpoint. What three or more funds give instead (kind matrix): - `computed` (boolean): false when fewer than two of the funds hold shares that can be overlapped (see reason). - `reason` (string): Why nothing is computed, when computed is false. - `skipped` (object): The tickers not covered, under not_covered, with what is covered (covered_issuers, also_covered and hint). Absent when every ticker is covered. - `pairs` (array of object): Every pair of the funds holding shares, the largest overlap by weight first: pair, by_weight, share_of_first, share_of_second and companies_in_both, as overlap gives them for two funds, and same_ticker_two_companies when a ticker stands for two companies. - `same_ticker_note` (string): What same_ticker_two_companies means, when a pair has it. - `issuer_overlap_pairs` (array of object): Every pair of the fixed income funds by issuer overlap, largest first: pair, by_weight, share_of_first, share_of_second, issuers_in_both. Never mixed with pairs. - `issuer_overlap_note` (string): How to read issuer_overlap_pairs, when there are some. Each answer carries the date and source of every fund's holdings, and source names the files it is computed from. ## Look-through of a portfolio, computed: `/api/v1/lookthrough?portfolio={portfolio}` The companies a portfolio holds underneath, from portfolio, its funds separated by commas, each with its weight or amount after a colon (VOO:60,QQQ:40 or VOO:40000,QQQ:25000), or none for equal weights. Computed with the code of the MCP tool get_etf_portfolio_lookthrough: each company's weight, its value in the unit of the amounts, and the funds it comes through. top (1 to 200, 25 by default) says how many companies; currency, three letters, is echoed and never converted. A fund renamed is read under its new ticker, which renamed gives. format=csv, or /api/v1/lookthrough.csv, gives one row per company. 1 to 6 funds, whose files weigh at most 30 KB, a file of the other layers a third of its size, and hold at most 1,100 lines between them. ```json { "…": "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" } ``` - `page_url` (string or null): The web page whose HTML, as the server sends it, prints the answer's figure, so that it reads without JavaScript: for a pair, its written comparison when there is one, else its "Does it diversify me?" answer within that answer's limits; for three funds or more, the x-ray the site wrote of the same funds; for a look-through, the x-ray the site wrote of the portfolio at the same weights (listed under pages in /og/answers.json), or for one fund, its page. Null where no page prints the figure yet: any other overlap of three funds or more or look-through of two funds or more, a pair past those limits, a pair of bond funds. - `share_url` (string): The address whose HTML reproduces the whole answer on the site: for a pair, its "Does it diversify me?" answer within that answer's limits; for three funds or more and for a portfolio, the x-ray the site wrote of the same funds (listed under pages in /og/answers.json), each weight in percent to 0.01 point and never an amount, in the order of the funds the site wrote it in. Absent where no page prints the answer. - `priced` (boolean): true when the portfolio gives each fund a weight or an amount; false when every fund counts equally. - `portfolio_value` (number or null): The sum of the weights or amounts of the funds looked through: the funds under not_looked_through and skipped are left out of it, as they are left out of the percentages. Null when none is given. - `currency` (string or null): The currency given, upper case, echoed and never converted; unstated when amounts are given without one. Null when none is given. - `prices_as_of` (string or null): The price date of the figures read from weekly returns. Null when no fund has prices. - `funds` (integer): How many funds are looked through. - `distinct_companies` (integer): How many distinct holdings they hold between them, counted by ticker: two share classes of one company (GOOGL and GOOG) count as two. - `top_10_weight_pct` (number): The weight of the ten largest companies, in percent of what is looked through, summed unrounded and rounded once. - `looked_through_pct` (number): The part of the portfolio its covered funds make up that the funds looked through are, in percent, by amount or in equal parts: weight_pct and top_10_weight_pct are of that part, and not_looked_through names the rest. - `holdings_as_of` (object): Each fund's holdings date, by ticker: the date of its issuer file, or the quarter end its SEC filing describes. - `holdings_source` (object): Each fund's source, by ticker: issuer file, SEC Form N-PORT, trust's own SEC filing, sponsor's own holdings file, or prospectus, no holdings yet. - `companies` (array of object): The companies underneath, largest first, top of them (25 when top is left out). - `same_ticker_two_companies` (object): The tickers listed twice: once for the US company of that ticker, once, marked listed_abroad, for the foreign company whose local code it is in another fund, with a note. Absent when there is none. - `skipped` (object): The tickers not covered, under not_covered, with what is covered (covered_issuers, also_covered and hint). Absent when every ticker is covered. - `not_looked_through` (array of object): The funds left out of the percentages and the value, each with why and fund_file. - `covered` (boolean): true when the funds are covered but the answer has no figures (see comparable or computed). - `computed` (boolean): false when none of the funds holds shares that can be looked through (see reason). - `reason` (string): Why nothing is computed, when computed is false. - `renamed` (object): Each ticker asked that a fund had before it was renamed, with its ticker now, under which the answer reads and names it. Absent when there is none. - `source` (object): The files the answer is computed from: each fund's page_url, null without a page, api_url, holdings_source and, for a fund from a filing, filing_url; benchmark_url, SPY's file, when a one-year beta is computed; license; and cite_as, the line to print under a figure. - `note` (string): Measurement, not investment advice. - `license` (string): The licence the data is published under. - `attribution` (string): How to credit the data: a link to the page of a fund the figure comes from, or to this address, where the medium allows one, the name where it does not. - `docs` (string): The reference of this endpoint. A company, in companies: - `ticker` (string): The company's key, as the funds' holdings write it. - `weight_pct` (number): Its weight, in percent of what is looked through. - `weight_pct_2dp` (number): Its weight to two decimals, rounded once from the unrounded sum, as the x-ray page prints it. - `through` (array of object): Each fund it comes through, the largest first, with its part in percent of what is looked through. - `value` (number or null): Its value, in the unit of the weights or amounts given. Null when none is given. - `listed_abroad` (boolean): true for a foreign company's line whose local code is a US ticker too. Absent otherwise. The analytics record its tickers, never a weight or an amount. The answer, which repeats them, is kept in the edge cache for up to a day under its query, and served only to the same query. ## Several fund files, computed: `/api/v1/batch?funds={funds}` The files of the funds in funds, a list separated by commas, in one answer keyed by ticker: each exactly what /api/v1/fund/{ticker}.json answers, the answer composed for a fund of another layer included, with the tickers not covered listed with the reason /fund/ gives. 1 to 10 funds. The files of the other layers composed in one call add up to at most 55 KB; the first is always composed. ```json { "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" } ``` - `asked` (array of string): The tickers asked for, upper case, each once, in the order asked. - `found` (integer): How many of them are in funds. - `not_covered` (array of object): The tickers with no fund file, each with error not_covered, ticker and message: reason has_security_file and security for one with a stock file, else reason no_file and fund, its own address, which gives the specific reason, and covered. - `not_included` (array of object): Funds of the other layers past what one call composes, each with ticker, fund, its own address, and reason over_budget. Absent when there is none. - `not_included_note` (string): Why not_included is there. - `renamed` (object): Each ticker of a fund renamed, with the ticker of the file served under it. Absent when there is none. - `funds` (object): Each fund found, by ticker as asked: what /api/v1/fund/{ticker}.json answers, a fund file of the stock layers byte for byte, or the answer composed for a fund of another layer. - `license` (string): The licence the data is published under. - `attribution` (string): How to credit the data: a link to the page each fund file's cite_as names where the medium allows one, the name where it does not. - `docs` (string): The reference of this endpoint. No CSV: each fund's holdings are at /api/v1/fund/{ticker}.csv. ## A screen of funds, computed: `/api/v1/screen?holds={holds}` The funds of funds.json that pass every filter given: issuer and category, matched whole whatever the case, a category by its id or its label; layer (issuer_files, sec_nport, sec_nport_bonds, sec_nport_multi_asset, sec_nport_derivatives, trust_filings, sponsor_files, prospectus); expense_ratio_max, in percent a year; aum_min, in billions of US dollars, read from aum_b or else the net assets of the fund's filing; holds, a security with a stock file, with min_weight in percent. sort is weight, aum, expense_ratio, positions, ticker; limit and offset page the answer. format=csv, or /api/v1/screen.csv, gives the page as rows, and a last row with the address of the next ones when there are more. limit 1 to 100, 50 by default; a CSV page holds 1 to 50, 50 by default; holds takes a security with a stock file. ```json { "…": "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" } ``` - `as_of` (string): The date of funds.json, the price date. - `filters` (object): The filters applied, as read: issuer as the data spells it; category as the category's id, whether it was asked by id or by label, and category_asked beside it when it was asked by a category name the site printed before 9 October 2026, which the screener reads for as long as v1 is served (funds-columns.json category_aliases); and holds_reads_as when the holders are read under another key: BRK.B for BRK-B, or the key an old one reads as now. - `sort` (string): The order of funds: weight (with holds) or aum, largest first by default; expense_ratio and ticker smallest first; positions largest first. A fund without the figure comes last. - `total` (integer): How many funds pass the filters. - `offset` (integer): Where this page starts in them. - `limit` (integer): How many funds a page holds at most. - `count` (integer): How many funds this page holds. - `funds` (array of object): The funds of this page. - `next` (string or null): The address of the next page. Null on the last one. - `source` (object): The files read, under api_urls: funds.json and, for holds, the stock file; and cite_as. - `license` (string): The licence the data is published under. - `attribution` (string): How to credit the data: a link to the page of a fund the figure comes from, or to this address, where the medium allows one, the name where it does not. - `docs` (string): The reference of this endpoint. A fund, in funds: - `ticker` (string): The fund's ticker. - `name` (string): Its name. - `layer` (string): Its layer: issuer_files, sec_nport, sec_nport_bonds, sec_nport_multi_asset, sec_nport_derivatives, trust_filings, sponsor_files, prospectus. - `issuer` (string or null): Its issuer, as funds.json names it. Null when unknown. - `category` (string or null): Its category, TickerInside's own, set every night from the fund's file (its name in funds.json c; https://tickerinside.com/etf/category/). Null for a fund the build has not classified. - `category_id` (string or null): The id of that category, which never changes meaning. Null with category. - `expense_ratio` (number or null): Its expense ratio, in percent a year. Null when unknown. - `aum_b` (number or null): Its assets in billions of US dollars, from market data. Null when unknown. - `net_assets` (number or null): Its net assets in US dollars on report_date, from its filing. Null for a fund read from its issuer's file. - `positions` (integer): How many positions its file lists. - `report_date` (string or null): The quarter end its filing describes, or the day its prospectus was filed. Null for a fund read from its issuer's file. - `weight_pct` (number): With holds: the security's weight in the fund, in percent. - `holdings_as_of` (string): With holds: the date of the fund's file the weight is read from. - `holdings_source` (string): With holds: issuer file or SEC Form N-PORT. - `fund_file` (string): The address of its file. - `page_url` (string or null): Its page. Null without one. holds reads the funds the stock's file lists, as the MCP tool find_etfs_holding_stock does. ## Does it diversify me?, computed: `/api/v1/diversify?have={have}&try={try}` With have alone, Find: the large US ETFs of a fixed, published list, in six groups, ranked by the correlation of their weekly returns with the portfolio's over up to 156 weeks, compared before rounding, leaving out any ETF held; the answer opens on the ETF of lowest correlation in each of the 3 groups where it is lowest, with its correlation on the weeks the portfolio fell, its volatility, the portfolio's volatility with 10% in it, what it holds, and its overlap with the portfolio when the files fit the limits of Find; every ETF of the list follows, ranked (mode find, the fields below). A sort of measurements by a published rule. For each fund of try, a list separated by commas, against the portfolio of the funds of have, each with its weight after a colon or none for equal weights: the overlap by weight with the portfolio looked through, the correlation of weekly returns with the portfolio's over up to three years and on the weeks it fell, the part in mega-cap tech, and the sectors and countries of its lines, with one sentence to quote for each, ranked by overlap, then by correlation. A trust, a derivative-based or a bond fund has no overlap by shares and counts in the correlation from its own weekly prices. /diversify/ with the same query renders the answer as a page, which share_url gives. No CSV. 1 to 6 funds in have and 1 to 6 in try. The files read weigh at most 90 KB, a compact file for half its size and a file of the other layers for a third, and hold at most 20,000 lines between them; each fund to try is compared with each fund held in at most 16,000 comparisons of lines in all, about the lines of the shorter of each pair. With have alone, Find ranks the list for any portfolio of up to 6 funds with weekly returns; the overlap of its 3 runs when the files of both sides fit the lower limits of Find, and overlap says whether it ran. ```json { "…": "2 more fields", "question": "Does VXUS or SPMO diversify a portfolio of QQQ 60%, SMH 20% and GLD 20%?", "…": "1 more field", "answers": ["VXUS has an overlap of 0.6% by weight with a portfolio of QQQ 60%, SMH 20% and GLD 20%, by the issuer files of 2026-08-31 for VXUS and 2026-10-10 for QQQ, and the Form N-PORT filing of 2026-06-30 for SMH; its weekly returns had a 0.75 correlation over 156 weeks to 2026-10-09, and 0.65 over the 57 weeks the portfolio fell.", "… 1 more"], "…": "1 more field", "candidates": [{"ticker": "VXUS", "…": "5 more fields", "overlap": {"by_weight_pct": 0.6, "…": "1 more field", "companies_in_both": 4, "…": "1 more field"}, "correlation": {"weekly": 0.75, "weeks": 156, "from": "2023-10-20", "to": "2026-10-09", "down_weeks": 0.65, "down_weeks_count": 57, "with": ["QQQ", "SMH", "GLD"]}, "…": "2 more fields", "mega_cap_tech_pct": 0, "…": "2 more fields", "rank": 1, "…": "1 more field"}], "…": "1 more field", "prices_as_of": "2026-10-09", "…": "1 more field", "share_url": "https://tickerinside.com/diversify/?have=QQQ:60,SMH:20,GLD:20&try=VXUS,SPMO", "…": "6 more fields" } ``` - `kind` (string): Always diversify. - `mode` (string): compare, the check of the funds of try against the funds of have. With have alone the answer is Find, mode find, another shape (DiversifyFind). - `question` (string): The question answered, in words: the funds to try and the portfolio of the funds held, with their weights. - `answer` (string): The answer in one sentence, to quote as it is: of the funds to try, the one with the lowest overlap and the one with the lowest weekly correlation, with the figures and their period, or for one fund to try its two figures; the line /diversify/ prints under the question. - `answers` (array of string): One sentence per fund to try, in the order of candidates, to quote as it is: its overlap with the portfolio, the correlation of weekly returns with the portfolio's over the weeks both have and on the weeks the portfolio fell, and the holdings dates, or why a figure is not measured. - `have` (object): The portfolio of the funds held: each fund (funds) with its weight_pct, name, holdings_as_of, holdings_source, holds_shares and weekly_returns, the number of weekly returns its file has; weights, given or equal; looked_through_pct, the part of the portfolio in funds that hold shares; holds_no_shares; returns_from, the funds its weekly returns are computed from, and no_price_history; no_breakdown, the funds holding shares whose file gives no breakdown; mega_cap_tech_pct, sectors and countries as each candidate has them, its funds' at their weights, in percent of the whole portfolio; and its sentence. - `candidates` (array of object): Each fund to try, ranked (see ranking). - `ranking` (string): The rule of the order of candidates, in words. - `prices_as_of` (string): The last week of the weekly returns, the date of the prices. - `definitions` (object): How each figure is computed, in the words /diversify/ prints: overlap, share_of_candidate (the part of the candidate in companies the portfolio holds), correlation, down_weeks, sectors and countries; the companies counted as mega-cap tech (mega_cap_tech: rule and companies, each with its name and tickers), the fixed list every fund file's breakdown counts; and sectors_stated_from_pct. - `skipped` (object): The tickers not covered, under not_covered, left out of the answer. Absent when every ticker is covered. - `renamed` (object): Each ticker asked that a fund had before it was renamed, with its ticker now, under which the answer reads and names it. Absent when there is none. - `share_url` (string): The page of this answer, /diversify/ with the same query, which renders it for a person or an assistant that fetches it. - `api_url` (string): This answer's own address. - `source` (object): The files the answer is computed from: each fund's page_url, null without a page, api_url and holdings_source; reference_url, the file of mega-cap tech and the names of the sectors and countries; license; and cite_as. - `note` (string): Measurement, not investment advice. - `license` (string): The licence the data is published under. - `attribution` (string): How to credit the data: a link to the page of a fund the figure comes from, or to this address, where the medium allows one, the name where it does not. - `docs` (string): The reference of this endpoint. A fund to try, in candidates: - `ticker` (string): The fund to try. - `name` (string): Its name. - `holdings_as_of` (string): The date of its holdings: its issuer file, or the quarter end its filing describes. - `holdings_source` (string): Its source: issuer file, SEC Form N-PORT, trust's own SEC filing, sponsor's own holdings file, or prospectus, no holdings yet. - `fund_file` (string): The address of its fund file. - `page_url` (string or null): Its page. Null without one. - `overlap` (object or null): In percent: by_weight_pct, the sum over the companies it and the portfolio both hold of the smaller of its weight and the portfolio's, the portfolio looked through its funds at their weights; share_of_candidate_pct, the part of the fund in those companies; companies_in_both, the holdings both have, counted by ticker; and largest_shared, up to five, each with in_candidate_pct, in_have_pct and counted_pct. Null for a fund that holds no shares, or when no fund held does (see not_measured). - `correlation` (object or null): Of weekly returns, the fund's against the portfolio's: weekly, over weeks weeks from from to to, each the last close of its week (weeks run Saturday to Friday: a week closes on its Friday, or on the Thursday when the exchange is shut that Friday, and the last week on the data's last close); down_weeks, the same on the down_weeks_count weeks the portfolio fell, null under 20 of them; and with, the funds held whose returns the portfolio's are computed from. Null without 52 weeks in common (see not_measured). - `volatility_pct` (number): Its annualised weekly volatility over the weeks of its correlation, in percent; absent when the correlation is not measured. - `with_10_pct` (object): The portfolio's annualised weekly volatility with 10% in this ETF and 90% in the ETFs held at their weights, rebalanced weekly (volatility_pct), against the portfolio alone (instead_of_pct), over the weeks of its correlation; absent when the correlation is not measured. - `mega_cap_tech_pct` (number or null): The part of the fund in the companies definitions.mega_cap_tech lists, in percent to one decimal, from its fund file's breakdown. Null for a fund that holds no shares or has no breakdown. - `sectors` (object or null): From its fund file's breakdown: known_pct, the part of the fund whose sector is found; coverage_pct, that part of its stock weight; stated, whether coverage_pct reaches definitions.sectors_stated_from_pct; and weights, when stated, each sector with its id (sector), name and pct of the fund, largest first. Null as mega_cap_tech_pct is. - `countries` (object or null): From its fund file's breakdown, in percent of the fund: us_pct, the United States; weights, up to six countries, largest first, each with its ISO code (country), name and pct; and other_pct, the rest. Null as mega_cap_tech_pct is. - `not_measured` (object): Why a figure is null, by figure: overlap, correlation, down_weeks or profile. Absent when every figure is given. - `rank` (integer): Its place in the order of ranking, from 1. - `sentence` (string): Its sentence, as answers gives it. What have alone gives (mode find): /api/v1/diversify?have=VOO:60,QQQ:20,VXUS:20: - `kind` (string): Always diversify. - `mode` (string): Always find: have alone, no try. - `question` (string): The question answered, in words: which ETF in each group of the list had the lowest weekly correlation with the portfolio of the funds held, with their weights; when a fund held has no price history here, with the funds of returns_from, at their weights among them, which every figure of weekly returns names. - `answer` (string): The answer in one sentence, to quote as it is: the ETF of lowest weekly correlation in each of the 3 groups where it is lowest, each with its group and figure, and the weeks with their last date; the line /diversify/ prints under the question. - `answers` (array of string): One sentence per ETF of lowest, to quote as it is: its weekly correlation with the portfolio over the weeks and on the weeks the portfolio fell, its place in its group, and its overlap by weight with the holdings dates when measured. - `have` (object): The portfolio of the funds held: each fund (funds) with its weight_pct, name, weekly_returns, holdings_as_of, holdings_source, holds_shares and page_url; weights, given or equal; returns_from, the funds its weekly returns are computed from, and no_price_history; volatility_pct over its weeks, weeks and to, of the weekly returns of the funds of returns_from; looked_through_pct; and mega_cap_tech_pct, sectors and countries, its funds' breakdowns at their weights, each fund's from its own file whether it has a price history here or not, the same figures as the check of the same portfolio; null when one of its funds holding shares has none, or when a fund's file is more than the answer reads beside the ranking, which its note names. - `list` (object): The list ranked: its name, list_date (the day it was chosen; a change of the list is a new date), about (the list in one sentence), left_out_on_purpose (what the list leaves out, in words), count, ranked (tonight, leaving out the funds held and any without weekly returns tonight), groups (id, label and tickers, in the order of the list), held_and_left_out, no_weekly_returns_tonight, and url, the list as a file. - `rule` (string): The rule of the ranking, in words, as the page prints it. - `lowest` (array of object): The ETF of lowest weekly correlation in each of the 3 groups where it is lowest, lowest first: a sort of the list's measurements by its published rule. - `lowest_by_group` (array of object): The ETF of lowest weekly correlation in every group, lowest first: group, group_label, ticker, weekly and weeks. - `ranked` (array of object): Every ETF of the list ranked, lowest weekly correlation first before rounding, an exact tie in the order of the list: rank, ticker, name, group, group_label, page_url, weekly, down_weeks and weeks. - `overlap` (string): measured when the overlap of the 3 with the portfolio ran, the files of both sides within the limits of Find; not_measured otherwise, and overlap is null in lowest. - `overlap_answered_by` (object): When overlap is not_measured, the check that answers it in one call: tickers, the ETFs of lowest that hold shares; page, the check's page; and diversify, its JSON answer, each with the overlap by weight of those ETFs with the portfolio. Absent when no check of them fits the limits of one call. - `ties` (array of object): An ETF of lowest whose weekly correlation prints the same as others of its group: ticker, with, printed. The order is before rounding. Absent without one. - `prices_as_of` (string): The last week of the weekly returns, the date of the prices. - `definitions` (object): How each figure is computed, in the words /diversify/ prints: correlation, down_weeks, volatility, with_10_pct, overlap, mega_cap_tech, sectors and countries. - `share_url` (string): The page of this answer, /diversify/?have=, which renders it for a person or an assistant that fetches it. - `api_url` (string): This answer's own address. - `source` (object): The files the answer is computed from: each fund's page_url and api_url; list_url, the list; license; and cite_as. - `note` (string): Measurement, not investment advice. - `license` (string): CC BY 4.0. - `attribution` (string): How to credit the data. - `docs` (string): This endpoint's reference. An ETF of the list, in lowest: - `rank` (integer): Its place among the 3, lowest first, from 1. - `ticker` (string): The ETF of the list. - `name` (string): Its name. - `group` (string): Its group in the list, by id. - `group_label` (string): Its group, in words. - `page_url` (string or null): Its page. Null without one. - `fund_file` (string): The address of its fund file. - `holdings_as_of` (string): The date of its holdings. - `holdings_source` (string): Its source: issuer file, SEC Form N-PORT or trust's own SEC filing. - `correlation` (object): Of weekly returns, the ETF's against the portfolio's, as a candidate's in the check: weekly, weeks, from, to, down_weeks, down_weeks_count and with. - `volatility_pct` (number): Its annualised weekly volatility over the same weeks, in percent. - `with_10_pct` (object): The portfolio's annualised weekly volatility with 10% in this ETF and 90% in its funds at their weights, rebalanced weekly (volatility_pct), against the portfolio alone (instead_of_pct), over weeks to to. - `overlap` (object): Its overlap by weight with the portfolio looked through, as a candidate's in the check, when measured; null otherwise, and for an ETF that holds no shares. - `mega_cap_tech_pct` (number): Its part in mega-cap tech, from its fund file's breakdown; null for an ETF that holds no shares. - `sectors` (object): Its sectors, from its fund file's breakdown, as a candidate's in the check. - `countries` (object): Its countries, from its fund file's breakdown, as a candidate's in the check. - `holds` (string): For an ETF that holds no shares, what it holds in two words. - `composition` (array of object): For an ETF that holds no shares, what it holds by kind, up to three, each with label and pct. - `sentence` (string): Its sentence, as answers gives it. The list, /api/v1/diversify/candidates.json: - `name` (string): The list's name. - `list_date` (string): The day the list was chosen. A change of the list is a new date. - `about` (string): The list in one sentence. - `left_out_on_purpose` (array of string): What the list leaves out on purpose, in words. - `weeks_end` (string): The last week of the weekly returns in w, the date of the prices. - `rule` (string): The rule of the ranking, in words, as every answer prints it. - `top` (integer): How many groups an answer opens on. - `min_weeks` (integer): The fewest weekly returns a correlation is computed on. - `groups` (array of object): The groups in the order of the list: id, label, one (an ETF of the group, in a sentence) and tickers. - `unit` (string): How w is written. - `left_out_tonight` (array of string): The ETFs of the list with no weekly returns in tonight's files, left out of every ranking until they have them. - `funds` (array of object): Each ETF of the list with weekly returns tonight, in the order of the list. - `license` (string): CC BY 4.0. - `reference_weight` (integer): What /api/v1/diversify/reference.json counts for against the limits of an answer, in the units of size. An ETF of the list, in funds: - `t` (string): Its ticker. - `g` (string): Its group, by id. - `vol` (number): Its annualised weekly volatility over 156 weeks, in percent, as its fund file gives it. - `n` (string): Its name. - `page` (string or null): Its page on the site. Null without one. - `size` (integer): What its file counts for against the limits of an answer: a file under /fund/ its length, its compact file under /diversify/funds/ half of that file's, a file under /etf/ a third. - `lines` (integer): How many holdings the overlap reads of it; 0 for an ETF that holds no shares. - `l` (string): Its source layer, as source_layer in its fund file: issuer, sec_nport, sec_nport_bonds, trust_filings and the others. - `h` (string): The date of its holdings. - `bd` (object): For an ETF that holds shares, its breakdown, the one its fund file gives: sectors_pct, no_sector_pct, sector_coverage_pct, sectors_stated, other_funds_pct, mega_cap_tech_pct and countries_pct. - `comp` (array of object): For an ETF that holds no shares, what it holds by kind, up to three, each with label and pct of its net assets. - `w` (array of integer): Its weekly returns as whole numbers of 0.0001 (divide by 10,000: 47 is 0.47%), oldest first, ending at weeks_end; null for a week without a return. One ETF's weekly returns, /api/v1/diversify/weekly/{ticker}.json: /api/v1/diversify/weekly/voo.json: - `t` (string): Its ticker. - `n` (string): Its name. - `page` (string or null): Its page on the site. Null without one. - `size` (integer): What its file counts for against the limits of an answer: a file under /fund/ its length, its compact file under /diversify/funds/ half of that file's, a file under /etf/ a third. - `lines` (integer): How many holdings the overlap reads of it; 0 for an ETF that holds no shares. - `l` (string): Its source layer, as source_layer in its fund file: issuer, sec_nport, sec_nport_bonds, trust_filings and the others. - `h` (string): The date of its holdings. - `bd` (object): For an ETF that holds shares, its breakdown, the one its fund file gives: sectors_pct, no_sector_pct, sector_coverage_pct, sectors_stated, other_funds_pct, mega_cap_tech_pct and countries_pct. - `comp` (array of object): For an ETF that holds no shares, what it holds by kind, up to three, each with label and pct of its net assets. - `w` (array of integer): Its weekly returns as whole numbers of 0.0001 (divide by 10,000: 47 is 0.47%), oldest first, ending at end; null for a week without a return. - `end` (string): The last week of w, the date of the prices. - `solo` (object): Its own ranking against the list as a one-ETF portfolio, when the list ranks it: list_date, lowest (the 3 of the answer, in order) and rows, every ETF of the list not held as [ticker, weekly correlation, on down weeks, weeks, down weeks], the correlations in hundredths (divide by 100), lowest first before rounding. The files Find reads, public like every file under /api/v1/. candidates.json is the list: its date, its groups, its rule in words, and each ETF of it with its weekly returns, its breakdown or what it holds, and what its file counts for against the limits of an answer. /api/v1/diversify/weekly/{ticker}.json, in lower case, is one ETF's weekly returns and breakdown, for every ETF with at least 52 weekly returns whose last week is the list's, with its own ranking against the list. An answer of have alone is a sort of these measurements by the published rule, the same list for every portfolio: a ranking can be recomputed from these files alone, as Pearson's correlation of w against the portfolio's weekly returns at its weights. The analytics record its tickers, never a weight. The answer, which repeats the weights, is kept in the edge cache for up to a day under its query, and served only to the same query. ## 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-16", "count": 626, "…": "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": 948, "issuer": "iShares", "aum_b": 4.0, "page": true, "url": "https://tickerinside.com/etf/aaxj/", "api": "https://tickerinside.com/api/v1/fund/aaxj.json"}, "… 625 more"], "sec_count": 2049, "…": "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/"}, "… 2,048 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. ## The US-listed ETFs, and their coverage: `/api/v1/universe.json` One row for each ETF in Nasdaq Trader's symbol directory: ticker, name, fund or exchange-traded note, and the layer that covers it or why it is not covered yet. The coverage is measured here over the funds only; the same block is in index.json and status.json. - `as_of` (string): The price date across the whole site. - `available` (boolean): False, with an empty funds list, when the list of US-listed ETFs could not be read for this build. - `source` (string): Nasdaq Trader's symbol directory. - `file_date` (string): The day of the directory file. - `sentence` (string): The measured coverage in one sentence to quote. - `coverage` (object): The measure, the block of index.json coverage.universe: etfs, covered (with holdings), pct, by_layer, prospectus, with_file, with_objective, not_covered by reason, etns, other_products, outside_universe, file_date, source, sentence, all_us_etfs, headline, claim and assets. - `layers` (object): What each layer of fund files is. - `reasons` (object): Why a fund has no fund file, by code. - `funds` (array of array of string): One row for each US-listed ETF and each exchange-traded note the directory flags: [ticker, name, kind, layer, why]. kind: etf, etn (a debt of the issuing bank, not a fund) or other. layer: how the fund is covered, null when it is not yet, and why is then its reason. - `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 ticker of the list with no fund file answers 404 at /api/v1/fund/{ticker}.json; this file says why. ## Who holds what, issuer files: `/api/v1/holders.json` The reverse index of the 626 issuer files: for each of the 16,724 securities their funds hold, which of them hold it and at what weight. One file of 3.9 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-16", "holdings_as_of": {"CNRG": "2026-10-15", "CWI": "2026-10-15", "…": "624 more"}, "…": "1 more field", "securities": 16724, "…": "2 more fields", "holders": {"NVDA": [["GXPT", 19.88], ["IYW", 16.5999], "… 158 more"], "…": "16,723 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.0 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-16", "holdings_as_of": {"CNRG": "2026-10-15", "CWI": "2026-10-15", "…": "624 more"}, "…": "1 more field", "facts": {"7203.JP": {"n": "Toyota Motor Corp"}}, "holders": {"7203.JP": [["EWJV", 6.8909], ["RXI", 3.6642], "… 42 more"], "…": "6,125 more keys"}, "holders_sec_nport": {"7203.JP": [["IQDG", 4.095], ["BBJP", 3.9873], "… 80 more"], "…": "7,926 more keys"}, "sec_nport_as_of": {"IQDG": "2026-06-30", "BBJP": "2026-07-31", "…": "655 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 626 issuer files hold, with how many of them hold it and its largest weight, in one file of 792 KB. The list to walk before asking for stock files: its last place says whether a stock file exists. ```json { "as_of": "2026-10-16", "count": 16724, "…": "1 more field", "securities": [["NVDA", 160, 19.88, "Nvidia", 1, 1], ["MSFT", 158, 15.07, "Microsoft", 1, 1], "… 16,722 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. ## Identifiers that outlive a ticker: `/api/v1/identifiers.json` One row for each of the 10,868 funds and stocks with a file here: ticker, name, asset type, the exchange it is listed on, its composite and share class FIGIs from OpenFIGI, its SEC CIK and, for a fund, its SEC series and class ids, in one file of 1.3 MB, and the same rows in /api/v1/identifiers.csv. A ticker can change, and a ticker given up can pass to another security. Key your records on the composite FIGI or, for a fund, its SEC class id, not on the ticker: neither changes with the ticker nor passes to another security. A CIK names the company or trust that files with the SEC, and several securities can share one. ```json { "read_on": "2026-10-17", "count": 10868, "…": "1 more field", "fields": ["ticker", "name", "asset_type", "exchange", "composite_figi", "share_class_figi", "cik", "series_id", "class_id"], "…": "2 more fields", "securities": [["A", "Agilent Technologies", "stock", "NYSE", "BBG000C2V3D6", "BBG001SCTQY4", "0001090872", null, null], ["AA", "Alcoa Corporation", "stock", "NYSE", "BBG00B3T3HD3", "BBG00B3T3HF1", "0001675149", null, null], "… 10,866 more"], "…": "2 more fields" } ``` - `read_on` (string): The day the sources were last read. Each source's own date is in sources. - `count` (integer): How many securities are listed, the length of securities. - `note` (string): How to read the rows. - `fields` (array of string): The names of the columns of each row, in their order: ticker, name, then the fields of the identifiers object a fund or stock file carries. - `counts` (object): How many rows there are, by asset_type, and how many have each field. - `sources` (array of object): Where each column comes from: name, url, the fields it gives, read_on (for the directory, the date of its file) and, for OpenFIGI, its terms. - `securities` (array of [ticker, name, asset_type, exchange, composite_figi, share_class_figi, cik, series_id, class_id]): One row per fund and stock with a file here, in ticker order, in the columns of fields: [ticker, name, asset_type, exchange, composite_figi, share_class_figi, cik, series_id, class_id]. A fund's file is /api/v1/fund/{ticker}.json, a stock's /api/v1/sec/{ticker}.json. - `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 identifiers object of a fund or stock file, from /api/v1/fund/ivv.json: - `asset_type` (string): etf for a fund; etn for an exchange-traded note, a bank's debt with no holdings; stock for any other listed share: a company's stock, a depositary receipt, a closed-end fund. - `exchange` (string or null): The exchange the security is listed on, as Nasdaq Trader's directory names it: Nasdaq, NYSE, NYSE Arca, Cboe BZX and the others its codes stand for. Null when the directory does not list it. Unlike the identifiers, it changes when the listing moves. - `composite_figi` (string or null): The Financial Instrument Global Identifier of the US listing (the composite FIGI of exchange code US), from OpenFIGI, asked by ticker. FIGIs are in the public domain. Null until OpenFIGI answers for the ticker with one security of this asset type. - `share_class_figi` (string or null): The FIGI of the share class, the same on every market it trades in. Null with composite_figi. - `cik` (string or null): The SEC's Central Index Key, ten digits as EDGAR writes it, from the SEC's ticker files: the company's, or for a fund the registrant's, the trust that files for it and for its other funds. Several securities can share one, so key records on composite_figi or class_id instead. Null when the SEC's files do not list the ticker. - `series_id` (string or null): For a fund, the SEC's id of its series (S and nine digits), which tells it apart from the other funds of its registrant: from the SEC's fund ticker file, or from the Form N-PORT its holdings are read from where the two differ. Null for a stock, and for a trust that files as a company. - `class_id` (string or null): For a fund, the SEC's id of its share class (C and nine digits). Null when series_id is, or when it comes from the Form N-PORT and the fund ticker file lists the ticker under another series. Of them, 10,773 have a FIGI, 9,849 a CIK and 5,444 a series id; a field is null where its source does not list the security yet. Each fund and stock file carries its row's values under identifiers. ## ETF ownership, every stock: `/api/v1/ownership.json` The ETF ownership ledger. For each of the 3,345 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-16", "method": "ti-ownership/1", "…": "1 more field", "count": 3345, "…": "1 more field", "stocks": [["EU", 33.47, 19, "company"], ["URG", 32.89, 16, "company"], ["ATEN", 30.49, 97, "company"], "… 3,342 more"], "…": "2 more fields", "top10_share": {"pct": 27.9, "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. ## ETF Ownership Index: `/api/v1/ownership-index.json` The ETF Ownership Index (ti-ownership-index/1). For each stock with a figure in the ownership ledger: the share of its shares outstanding held by the covered US ETFs, at least, the funds counted, and top3_share_pct, the share of those funds' holdings held by the three funds holding the most. Then the market line, over one line per company, with the cap-weighted share of the companies' market value the ETFs hold, the mean, the median and the quartiles, and the same line by sector. Its CSV twin, /api/v1/ownership-index.csv, has the same rows. The methodology, with a worked example, is at /etf-ownership/methodology/. ```json { "…": "1 more field", "as_of": "2026-10-16", "method": "ti-ownership-index/1", "…": "6 more fields", "count": 3345, "columns": ["ticker", "company", "sector", "basis", "pct_lower_bound", "funds_counted", "top3_share_pct", "holdings_newest", "shares_outstanding_as_of"], "stocks": [["EU", "enCore Energy Corp.", null, "company", 33.47, 19, null, "2026-10-16", "2026-08-10"], ["URG", "Ur Energy Inc", null, "company", 32.89, 16, null, "2026-10-16", "2026-07-31"], "… 3,343 more"], "market": {"companies": 3241, "cap_weighted_pct": 7.88, "mean_pct": 8.68, "median_pct": 7.92, "p25_pct": 3.7, "p75_pct": 12.8, "companies_without_cap": 129, "cap_b": 83221.2}, "…": "9 more fields", "cite_as": "TickerInside, ETF Ownership Index (ti-ownership-index/1) of 2026-10-16: at least 7.88% of the combined market value of 3,241 US-listed companies held by the covered US ETFs, https://tickerinside.com/api/v1/ownership-index.json, CC BY 4.0", "…": "4 more fields" } ``` - `name` (string): The index's name. - `as_of` (string or null): The date of the ownership ledger the index reads: its newest holdings date. - `method` (string): The method of the index, ti-ownership-index/1, in /api/v1/methods.json. - `ledger_method` (string): The method of the figures it reads, ti-ownership/1. - `method_url` (string): Where both methods are written down, with their test vectors. - `methodology` (string): The methodology page: formulas, sources, dates, limits and a worked example. - `holdings_dates` (object or null): The oldest and newest holdings dates counted across the stocks. - `shares_outstanding_dates` (object or null): The oldest and newest dates of the SEC's counts of shares outstanding used. - `caps_as_of` (string or null): The price date of the market caps that weight the lines; they enter no stock's figure. - `count` (integer): How many stocks have a figure, the rows of stocks. - `columns` (array of string): The names of the places of each row of stocks. - `stocks` (array of [ticker, company, sector, basis, pct_lower_bound, funds_counted, top3_share_pct, holdings_newest, shares_outstanding_as_of]): One row per stock with a figure, most held first, as columns names them. - `market` (object or null): The line over every company: described below. - `sectors` (array of object): The line of each sector with at least 5 companies, by name: the same fields and sector. - `class_basis_left_out` (integer): How many figures of one class alone are in stocks and left out of the lines. - `concentration_min_funds` (integer): The fewest funds counted for a top3_share_pct. - `concentration_not_published` (object): How many stocks have a null top3_share_pct, by reason (refusals of ti-ownership-index/1 in methods.json). - `held_back` (object or null): Set when tonight's ledger was held back by its checks: the index then reads the last ledger that passed. - `failed` (boolean): True when the index could not be computed tonight: no rows and no lines, the history as it was. - `history` (string): The daily history, with the changes over 5 and 20 market days (history terms). - `csv` (string): The rows of stocks as CSV, the same columns. - `note` (string): How to read the file. - `cite_as` (string or null): A citation line: the index, its date, the market line 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): CC BY 4.0. - `attribution` (string): Credit TickerInside with a link to this file, or to the page that shows the figure, wherever the medium allows a link, and by name where it does not. How you mark the link is up to you. The market line, and each line of sectors: - `companies` (integer): Companies in the line, one per company on a company basis. - `cap_weighted_pct` (number or null): Sum of each company's figure times its market cap over the sum of their caps, rounded down: the share of their combined market value held by the covered US ETFs, at least. - `mean_pct` (number or null): The mean of the companies' figures, rounded down. - `median_pct` (number or null): The median company's figure. - `p25_pct` (number or null): The first quartile, by nearest rank. - `p75_pct` (number or null): The third quartile, by nearest rank. - `companies_without_cap` (integer): Companies without a market cap, in the mean and quartiles and left out of cap_weighted_pct. - `cap_b` (number or null): The companies' combined market cap, in billions of dollars. A lower bound, like the ledger it reads: funds outside the coverage, and covered funds whose count could not be used, are not in it. Market caps weight the lines and enter no stock's figure. Under CC BY 4.0. ## ETF Ownership Index, daily history: `/api/v1/ownership-index/history.json` One row per market close of the market line and of each sector line: the levels of the night the close was first published, and the change of ETF ownership ending on the close over 1, 5 and 20 market days, weighted by market cap. Then each stock's changes ending on the latest close, in percentage points of its shares outstanding, from the net shares the funds read daily bought and sold, as the ETF flows publish them. Its CSV twin, /api/v1/ownership-index/history.csv, has the rows of every line. ```json { "…": "4 more fields", "first_close": "2026-09-29", "last_close": "2026-10-12", "…": "1 more field", "series_columns": ["date", "as_of", "companies", "cap_weighted_pct", "mean_pct", "median_pct", "p25_pct", "p75_pct", "companies_without_cap", "cap_b", "change_1d_pp", "change_1d_cap_pct", "change_5d_pp", "change_5d_cap_pct", "change_20d_pp", "change_20d_cap_pct", "rebuilt"], "market": [["2026-10-09", null, null, null, null, null, null, null, null, null, 0.0061, 90.7, 0.0124, 85.5, null, 0.0, true], ["2026-10-12", "2026-10-13", 3503, 11.41, 10.64, 9.88, 3.68, 16.54, 252, 84647.2, 0.0067, 88.8, 0.0233, 83.5, null, 0.0, false]], "…": "1 more field", "stocks_columns": ["ticker", "change_1d_pp", "change_5d_pp", "change_20d_pp", "null_1d", "null_5d", "null_20d"], "stocks": [["A", 0.0121, 0.0328, null, null, null, null], ["AA", 0.0079, 0.0225, null, null, null, null], "… 3,343 more"], "…": "11 more fields" } ``` - `name` (string): The history's name. - `method` (string): The method of the index, ti-ownership-index/1. - `flows_method` (string): The method of the flows the changes are read from, ti-flows/1. - `methodology` (string): The methodology page. - `first_close` (string or null): The first close of the history. - `last_close` (string or null): The close of the changes in stocks: the flows' latest close. - `windows` (object): For 1d, 5d and 20d: from, the close the change starts after, to, the close it ends on, and covered, whether every close between is a complete close of the flows. - `series_columns` (array of string): The names of the places of each row of market and sectors. - `market` (array of [date, as_of, levels, changes, rebuilt], as series_columns): The market line, one row per close, oldest first. - `sectors` (object of the same rows, by sector): Each sector's line, one row per close, by sector. - `stocks_columns` (array of string): The names of the places of each row of stocks. - `stocks` (array of [ticker, change_1d_pp, change_5d_pp, change_20d_pp, null_1d, null_5d, null_20d]): Each stock's changes over 1, 5 and 20 market days ending on last_close, in percentage points of its shares outstanding, and the reason each null one is null; a null reason with a null change means the window is not covered. - `not_measured` (object): For each window, how many stocks have no change, by reason. - `null_reasons` (object): Each reason a change is null, in words. - `index` (string): The index file. - `csv` (string): market and sectors as CSV rows, with the line's name in line. - `note` (string): How to read the file. - `cite_as` (string or null): A citation line: the closes 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 history terms, not CC BY 4.0. - `terms` (string): The terms in full, on the legal notice. - `attribution` (string): How to credit it, then what the history terms allow. A row is written the first night its close is published and never rewritten. The rows before the first night are rebuilt from the flows of that night: their changes only. Not under CC BY 4.0: the history terms apply. ## 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-16", "since": "2026-09-01", "count": 633, "funds": [{"t": "AAXJ", "first": "2026-09-02", "last": "2026-10-15", "file_dates": 31, "cadence": "daily", "traded_pp_from": "2026-09-29", "ended": null, "url": "https://tickerinside.com/api/v1/history/aaxj.json"}, "… 632 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 or null): 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-15", "…": "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, []], "… 29 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}, "… 19 later steps"], "overlap_history": {"with_top_funds_by_overlap": 10, "series": {"IVVW": [["2026-09-24", 99.7], ["2026-09-25", 99.7], "… 14 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-15, 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 or null): 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. ## ETF flows, the day's summary: `/api/v1/flows.json` What the US ETFs read daily from their issuers' files bought and sold, security by security, from the change in shares held between each fund's previous file and its file of date, each file placed at the market close it reflects: the largest net additions and reductions by value, in percent and beyond the funds' own growth, the securities that entered or exited funds tracking the same index, the corporate actions, and each of the last 20 closes. Its CSV twin, /api/v1/flows.csv, lists every security moved on date. ```json { "date": "2026-10-12", "newest_file": "2026-10-16", "…": "2 more fields", "coverage": {"funds_read_daily": 624, "funds_counted": 609, "issuers": ["Global X", "Invesco", "SPDR", "iShares"], "net_assets_usd": 6248330747647, "share_of_stock_etf_assets_pct": 71.6, "not_counted": {"fund_of_funds": 10, "no_file_for_date": 5, "no_longer_read": 7, "not_daily": 2}}, "added_by_value": [{"ticker": "NVDA", "name": "Nvidia", "funds_adding": 31, "funds_trimming": 13, "funds_entered": 0, "funds_exited": 0, "net_shares": 1306360, "net_shares_pct": 0.0911, "net_shares_beyond_growth": -113612, "net_value_usd": 293512213, "net_value_beyond_growth_usd": -25718871, "withheld": null}, {"ticker": "AAPL", "name": "Apple Inc.", "funds_adding": 29, "funds_trimming": 13, "funds_entered": 0, "funds_exited": 0, "net_shares": 752399, "net_shares_pct": 0.0882, "net_shares_beyond_growth": -82252, "net_value_usd": 254598223, "net_value_beyond_growth_usd": -28050983, "withheld": null}, "… 8 more"], "reduced_by_value": [{"ticker": "EBS.AT", "name": "Erste Group Bank AG", "funds_adding": 1, "funds_trimming": 3, "funds_entered": 0, "funds_exited": 1, "net_shares": -94268, "net_shares_pct": -1.2742, "net_shares_beyond_growth": null, "net_value_usd": -11492074, "net_value_beyond_growth_usd": null, "withheld": {"net_shares_beyond_growth": "one_fund_dominant", "net_value_beyond_growth_usd": "one_fund_dominant"}}, {"ticker": "DB1.DE", "name": "Deutsche Boerse AG", "funds_adding": 3, "funds_trimming": 2, "funds_entered": 0, "funds_exited": 0, "net_shares": -21329, "net_shares_pct": -0.4402, "net_shares_beyond_growth": null, "net_value_usd": -7110849, "net_value_beyond_growth_usd": null, "withheld": {"net_shares_beyond_growth": "one_fund_dominant", "net_value_beyond_growth_usd": "one_fund_dominant"}}, "… 8 more"], "…": "4 more fields", "index_events": [{"date": "2026-10-09", "ticker": "MRNA", "change": "entered", "funds": ["QQQ", "QQQM"], "same_index_as": "QQQ", "group_funds": 8, "text": "entered 2 of the 8 funds tracking the same index as QQQ on 2026-10-09"}, {"date": "2026-10-08", "ticker": "MRNA", "change": "entered", "funds": ["QYLD", "IQQ", "QNDX", "QYLG", "QRMI", "QTR"], "same_index_as": "QQQ", "group_funds": 8, "text": "entered 6 of the 8 funds tracking the same index as QQQ on 2026-10-08"}, "… 31 more"], "…": "12 more fields", "cite_as": "TickerInside, ETF flows of the close of 2026-10-12 from the issuers' files, https://tickerinside.com/api/v1/flows.json", "…": "5 more fields" } ``` - `date` (string or null): The market close of the figures: the newest close that nine in ten of the funds counted have a file of. Each file is placed at the close it reflects (Invesco dates a Friday's file on the Saturday), and each fund's change runs from its previous file to its file of this close. - `newest_file` (string or null): The newest close a file read reflects. A close is published once every fund still publishing has a file of it or of a later close, so date can be older. - `first_date` (string or null): The first close with a counted change: the first files carrying share counts in today's keys. - `method` (string): The method of the figures, ti-flows/1. - `coverage` (object): Which funds are counted; its fields are described below. - `added_by_value` (array of object): The ten securities with the largest net additions in dollars on date, the securities in not_ranked left out; a row is described below. - `reduced_by_value` (array of object): The ten with the largest net reductions in dollars. - `added_by_shares_pct` (array of object): The ten largest net additions in percent of the shares the funds held before. - `reduced_by_shares_pct` (array of object): The ten largest net reductions in percent. - `added_beyond_growth_by_value` (array of object): The ten largest net additions beyond the funds' own growth, in dollars: rebalancing and index changes rather than the creations of the funds' shares. - `reduced_beyond_growth_by_value` (array of object): The ten largest net reductions beyond the funds' own growth. - `index_events` (array of object): Securities that entered or exited two or more funds tracking the same index on the same close, in the last 20 trading days, newest first; described below. - `corporate_actions` (array of object): Mergers, spin-offs, takeovers, splits and uniform changes the files show in the last 20 trading days, newest first: no trades, so the lines a merger, a spin-off or a split moved are left out of the sums. Described below. - `not_ranked` (array of object): The securities moved on date that the six lists leave out, each with its reason: converted (both securities of a merger paid in shares), acquired_or_delisted, distribution, split or uniform_change (within three closes of a corporate action, or on a close where a line of theirs is left out for one), or fund_shares (the shares of a fund the site covers, held by another fund). - `funds_most_changed` (array of object): The ten funds whose step to date entered or exited the most lines; described below. - `days` (array of object): Each close of the last 20, newest first: how many funds have a step to it, whether nine in ten do (complete), how many securities moved, and its five largest net additions and reductions as [ticker, dollars, shares], the securities not ranked left out. - `not_counted` (array of object): The funds read daily that are not counted on date, each with its reason and its last file: fund_of_funds, whole_fund_counts (a file that counts every share class of a fund with mutual fund classes), no_share_counts, no_file_for_date, restated (a change of keys), no_previous_file or unreadable_file. - `file_gaps` (integer): How many lines the window leaves out because an issuer's file dropped them for a day and they came back with the same count. - `security` (string): The address of one security's flows, with {ticker} to fill. - `csv` (string): Every security moved on date, one row each, largest net value first. - `feed` (string): This summary as an RSS feed, one item per complete close. - `feed_fund` (string): One fund's holdings changes as an RSS feed, from its history, with {ticker} to fill. - `feed_stock` (string): One security's flows as an RSS feed, with {ticker} to fill. - `note` (string): How to read the figures. - `cite_as` (string): A citation line: the close 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 flows are published under: TickerInside's history terms, not CC BY 4.0, as they are computed from the archive. - `terms` (string): The terms in full, on the legal notice. - `attribution` (string): How to credit it, then what the history terms allow. The coverage object: - `funds_read_daily` (integer): The funds read from their issuers' files every business day. - `funds_counted` (integer): How many of them have a step to date that is counted. - `issuers` (array of string): The issuers of the funds counted. - `net_assets_usd` (integer or null): The counted funds' net assets, as their issuers' files state them. - `share_of_stock_etf_assets_pct` (number or null): The counted funds' share of the assets of the covered US stock ETFs, measured as the universe's share of assets is; null when not measured. - `not_counted` (object): How many funds of the archive are not counted, by reason, not_daily for a fund whose issuer publishes monthly. A row of the six lists: - `ticker` (string): The security's key: a US ticker, or a local code and market for a line listed abroad (7203.JP). - `name` (string or null): Its name, where known. - `funds_adding` (integer): How many funds hold more shares of it than in their previous file. - `funds_trimming` (integer): How many hold fewer. - `funds_entered` (integer): How many of those adding did not hold it before. - `funds_exited` (integer): How many of those trimming hold none now. - `net_shares` (integer or null): The change in shares held, summed over the funds. Null when fewer than three funds moved it or one fund makes more than 80% of it, as withheld says: a fund's share count is never published. - `net_shares_pct` (number or null): net_shares in percent of the shares the funds held before; null when fewer than three funds held it before or after, or one fund held more than 80% of it. - `net_shares_beyond_growth` (integer or null): The same change less the part in proportion to each fund's own growth across its step (b minus k times a, k the fund's median ratio of share counts). - `net_value_usd` (integer or null): net_shares valued at each file's own price per share: market value over shares, or weight times the fund's stated net assets over shares. Never an outside price. - `net_value_beyond_growth_usd` (integer or null): net_shares_beyond_growth valued the same way. - `withheld` (object or null): Why each null sum is null, as {field: reason}, or null: fewer_than_3_funds, one_fund_dominant (one fund makes more than 80% of the sum, or of the difference two published sums give, such as net_shares less net_shares_beyond_growth), gives_back_a_fund_count (the sums as printed, taken as one or two funds' own or compared with the figures published before for the same close, would give back a fund's share count) or not_all_valued. An index event: - `date` (string): The close. - `ticker` (string): The security. - `change` (string): entered or exited. - `funds` (array of string): The funds of the group it entered or exited on that close. - `same_index_as` (string): The group's largest fund. Two funds track the same index when they overlap by 98% or more by weight on their latest files. - `group_funds` (integer): How many funds the group has. - `text` (string): The event in words, to quote. A corporate action: - `date` (string): The first close the funds show it on; funds that book it later show it a close or two after. - `kind` (string): converted (a merger paid in shares: from exited while to rose, or entered, by the same ratio in funds of three or more indexes), distribution (a spin-off: to entered at the same ratio of from in funds of three or more indexes), acquired_or_delisted (from left the funds of two or more issuers with nothing replacing it, and half its holders left it or its price per share stood still), split (three quarters or more of the funds holding from changed their counts by one ratio within three closes, while its price per share in the files moved by the inverse ratio: a split, a reverse split, a bonus issue or a stock dividend) or uniform_change (the same ratio with no price move to match: named and not ranked, its lines kept in the sums). - `from` (string): The security converted, the parent of a distribution, the security taken over or delisted, or the security split or changed. - `to` (string or null): The security received: from itself for a split; null for acquired_or_delisted and uniform_change. - `ratio` (number or null): Shares of to per share of from, as the funds' counts show it (1.2 for a 6-for-5 bonus issue, 0.5 for a 1-for-2 reverse split); null for acquired_or_delisted. - `text` (string): The action in words, to quote. A security not ranked: - `ticker` (string): The security. - `reason` (string): converted, acquired_or_delisted, distribution, split, uniform_change or fund_shares. A fund of funds_most_changed: - `fund` (string): The fund's ticker. - `name` (string or null): Its name. - `previous` (string): The date its issuer gives the file its step is compared with. - `date` (string): The date its issuer gives its file, which can be a day after the close it reflects. - `entered` (integer): Lines that entered. - `exited` (integer): Lines that exited. - `increased` (integer): Lines whose share count rose. - `decreased` (integer): Lines whose share count fell. - `growth_pct` (number): The fund's own growth across the step, in percent: the median change of its share counts, mostly creations and redemptions of its shares. - `not_trusted` (integer): Lines left out of every sum, as no trade (see not_trusted in one security's flows). A day of days: - `date` (string): The close. - `funds` (integer): How many funds have a counted step to it. - `complete` (boolean): true when nine in ten of the funds counted on date do. - `securities_changed` (integer): How many securities a fund moved on it. - `added_by_value` (array of array of string): Its five largest net additions, as [ticker, dollars, shares]. - `reduced_by_value` (array of array of string): Its five largest net reductions. A change in shares held mixes the creations and redemptions of a fund's own shares with its rebalancing: read beyond_growth for the second. Only the funds read daily from their issuers are counted, never the funds known from SEC filings, and only common shares: futures, options and short positions are left out. A split, a bonus issue or a stock dividend, a count in other units, a line a file dropped for a day, a change of ticker and the lines a merger or a spin-off moved are left out as no trade. A sum is published only when three or more funds make it and no one fund more than 80% of it; withheld says why one is null. Feeds: /feeds/flows.xml, /feeds/fund/{ticker}.xml, /feeds/stock/{ticker}.xml (RSS 2.0). Not under CC BY 4.0: the history terms apply. A feed reader may poll the feeds; fetching the shards or many securities' answers on a schedule to keep them is systematic extraction. ## ETF flows, one security: `/api/v1/flows/{ticker}.json` One security's flows: on date, how many funds added and trimmed it, the net change in shares, in dollars at the files' own prices and beyond the funds' own growth, the funds with the largest changes, with their weights only, and the lines left out as no trade; then one row per close of the last 20, its index entries and exits and its corporate actions. Composed when asked from the shard of the key's first character, /api/v1/flows/shards/{c}.json. - `ticker` (string): The security's key, as the holdings key it. - `name` (string or null): Its name, where known. - `date` (string or null): The close of latest, as in /api/v1/flows.json. - `newest_file` (string or null): The newest close a file read reflects. - `funds_holding` (integer): How many of the funds counted hold it in their newest file. - `funds_counted` (integer): How many funds are counted on date. - `latest` (object or null): Its flows on date; null when no fund moved it then. Described below. - `series` (object): One row per close of the last 20 it moved on, oldest first, with the columns named in columns: date, funds_adding, funds_trimming, funds_entered, funds_exited, net_shares, net_shares_beyond_growth, net_value_usd, and withheld, why the first null of the three sums is null (as in latest). No close newer than date is published. - `index_events` (array of object): Its entries and exits in funds tracking the same index, in the last 20 trading days, as in /api/v1/flows.json. - `corporate_actions` (array of object): The mergers, spin-offs, takeovers, splits and uniform changes it is part of in the last 20 trading days, as in /api/v1/flows.json; the lines a merger, a spin-off or a split moved are left out of its sums. - `method` (string): The method of the figures, ti-flows/1. - `note` (string): How to read the figures. - `summary` (string): The night's summary. - `feed` (string): This security's flows as an RSS feed. - `cite_as` (string): A citation line: the security, the closes of the window and this answer's address. - `cite_html` (string): The credit as HTML: a link to this answer, then its address. - `docs` (string): Where the answer is documented. - `license` (string): The history terms, not CC BY 4.0. - `terms` (string): The terms in full, on the legal notice. - `attribution` (string): How to credit it, then what the history terms allow. The latest object: - `date` (string): The close. - `funds_adding` (integer): How many funds hold more shares of it than in their previous file. - `funds_trimming` (integer): How many hold fewer. - `funds_entered` (integer): How many of those adding did not hold it before. - `funds_exited` (integer): How many of those trimming hold none now. - `single_fund` (boolean): true when one fund alone moved it: every sum is then null. - `net_shares` (integer or null): The change in shares held, summed over the funds. Null when fewer than three funds moved it or one fund makes more than 80% of it, as withheld says: a fund's share count is never published. - `net_shares_beyond_growth` (integer or null): The same change less the part in proportion to each fund's own growth across its step (b minus k times a, k the fund's median ratio of share counts). - `net_shares_pct` (number or null): net_shares in percent of the shares the funds held before; null when fewer than three funds held it before or after, or one fund held more than 80% of it. - `net_value_usd` (integer or null): net_shares valued at each file's own price per share: market value over shares, or weight times the fund's stated net assets over shares. Never an outside price. - `net_value_beyond_growth_usd` (integer or null): net_shares_beyond_growth valued the same way. - `valued_pct` (number or null): The share of the change in shares that a file valued. - `withheld` (object or null): Why each null sum is null, as {field: reason}, or null: fewer_than_3_funds, one_fund_dominant (one fund makes more than 80% of the sum, or of the difference two published sums give, such as net_shares less net_shares_beyond_growth), gives_back_a_fund_count (the sums as printed, taken as one or two funds' own or compared with the figures published before for the same close, would give back a fund's share count) or not_all_valued. - `funds` (object): The funds with the largest changes, largest by value first, at most eight, with the columns named in columns: fund, change (entered, exited, increased or decreased), weight_before and weight_after (percent of the fund, as its holdings files print them), previous and date (its two files, as its issuer dates them). No fund's share count is published, nor any figure of its own a count could be worked out from. - `not_trusted` (array of array of string): The funds whose line is left out of every sum, as [fund, reason]: price_per_share_jump (a split or a count in other units, by the file's own values), count_weight_mismatch (a count that moved against the weight), split_seen_in_other_files, price_unlike_other_funds (a price per share half again or more away from the other funds' line of the same key: another instrument under it), file_gap, rekeyed (a change of ticker), converted (a merger paid in shares), distribution (a spin-off) or split (a split, a bonus issue or a stock dividend found across the funds). A key no fund read daily held or moved in the last 20 trading days answers 404, reason not_held_by_daily_funds. Not under CC BY 4.0: the history terms apply. ## The manifest of a build: `/api/v1/manifest.json` Written last by every build: when it ran, the version of the API's shape and of the calculations, each source with its version, date and age in days, and one sha256 for each family of files. The sha256 of every file under /api/v1/ is in /api/v1/sha256sums.txt.gz, in the format of sha256sum. Give built_at and calculation.version beside a figure to cite the exact state it comes from. - `manifest_version` (integer): The version of this file's own shape: 1. A field added keeps it. - `built_at` (string): When the build that wrote every file listed here ran, in UTC. Give it beside a figure to cite the exact state it comes from. - `build_date` (string): The day of built_at. - `schema` (object): The version of the API's shape; its fields are described below. - `calculation` (object): The version of the calculations; its fields are described below. - `sources` (array of object): Each source of the data with its version, date and age in days on the day of the build; their fields are described below. - `files` (object): The list of every file with its sha256; its fields are described below. - `families` (object): One entry per family of files, keyed by a directory followed by a slash (fund/) or by the name of a file at the top (index.json): files, the number of files, bytes, their size, and sha256, the digest of the family's lines of the list, in their order, each ending with a newline. - `methods_url` (string): The methods of the computed figures, /api/v1/methods.json. - `contract` (string): The data contract this file belongs to: /contract/. - `docs` (string): Where this file is documented. - `license` (string): The licence the file 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 schema object: - `api` (string): The version in the path: v1. Inside it, fields are added, never removed or retyped. - `digest` (string): The sha256 of the tables the API reference and the OpenAPI description are written from: the names of the fields and codes and the types they fix, without their words. It is read from the code, never from a night's files, so the night's data never moves it; a field, a code or a type added to those tables does. - `openapi` (string): The OpenAPI description. The calculation object: - `version` (string): The first 16 hexadecimal characters of the sha256 of the method ids and the versions under readers: it moves when any of them does, and on no other night. - `methods` (array of object): Each method of methods.json, as id and since, the first day figures were published under it. - `readers` (object): The version of each reader and computation named here, by name: it rises when what it makes of the same input changes, and for issuer_file_read, price_read, returns_and_risk and computed_answers with any change to their code. key_scheme is how securities are keyed (2: a line abroad carries its market). Code not named here moves no version: a figure it corrects is recorded in corrections.json. A source, in sources: - `id` (string): The source: prices, a layer of fund files by its source_layer (issuer, sec_nport and the others), or directory, Nasdaq Trader's symbol directory. - `name` (string): The source in words. - `version` (string or null): The source's own version where it has one: the SEC's quarterly data set read (2026q2) for sec_nport, the file's date for the directory; null otherwise. - `date` (string or null): The date of the data: the last close for prices, the newest holdings date of the layer's fund files, the directory's file date. - `age_days` (integer or null): Days from date to the day of the build. - `oldest` (string or null): The oldest holdings date of the layer's fund files; null for prices and the directory. - `oldest_age_days` (integer or null): Days from oldest to the day of the build. - `median_age_days` (integer or null): The median, over the layer's fund files, of the days from their holdings date to the day of the build. - `funds` (integer or null): How many fund files of the layer; null for prices and the directory. The files object: - `count` (integer): How many files are listed: every file under /api/v1/ but this one and the list. - `bytes` (integer): Their size, added up. - `list` (string): The list, gzipped: /api/v1/sha256sums.txt.gz. - `list_sha256` (string): The sha256 of the list once unzipped. - `format` (string): How the list is written, and the command that checks a copy against it. The list holds every file under /api/v1/ but the manifest and the list. A family's sha256 is the digest of its lines of the list, so it is the same on two nights whose files of that family did not change. ## Every dated change: `/api/v1/changelog.json` Every entry of /changes/, newest first, each with an id that does not change. - `count` (integer): How many entries. - `newest` (string): The date of the newest entry. - `entries` (array of object): Every dated change, newest first; their fields are described below. - `contract` (string): The data contract this file belongs to: /contract/. - `docs` (string): Where this file is documented. - `license` (string): The licence the file 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. An entry: - `id` (string): The entry's id: its date and title in lower case words joined by hyphens. It does not change. - `date` (string): The day the change reached the site. - `title` (string): What changed, in one line. - `body` (string): What changed and what a program reading the files should do, in words. - `url` (string): The page that prints the entries: /changes/. ## What is kept for compatibility: `/api/v1/deprecations.json` Each field, key, answer, address and MCP tool name kept answering for compatibility, with what replaces it. The fund addresses and the tool names are read from the code that answers them. - `count` (integer): How many entries. - `rule` (string): What deprecated means here, in one sentence. - `aliases` (object): Each fund address the Worker answers with a 301 to the fund's file under its new ticker: {old ticker: new ticker}, lower case, as src/index.js lists them. - `entries` (array of object): What still answers but has a replacement; their fields are described below. - `contract` (string): The data contract this file belongs to: /contract/. - `docs` (string): Where this file is documented. - `license` (string): The licence the file 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. An entry: - `id` (string): The entry's id. It does not change. - `kind` (string): field, a field of a file; key, a way of keying a security; answer, an answer of an address; address, an address that leads to another; mcp_tool, a tool name of the MCP server. - `since` (string): The day it was replaced. - `what` (string): What is deprecated. - `where` (string): The file, address or server where it answers. - `replaced_by` (array of string): What to read or call instead. - `answers` (string): How it answers today. - `note` (string): Why, in words. - `removal` (null): Always null: nothing is removed inside v1. Nothing listed here is removed inside v1. ## The corrections registry: `/api/v1/corrections.json` Each figure that was published wrong and then corrected, newest first: the day the correction reached the files, the families of files it touched, the tickers, and what the files said before and say since. - `count` (integer): How many corrections. - `newest` (string): The date of the newest. - `kinds` (object): Each kind of correction, by code, in words. - `entries` (array of object): Every correction, newest first; their fields are described below. - `contract` (string): The data contract this file belongs to: /contract/. - `report` (string): How to report a figure that looks wrong. - `docs` (string): Where this file is documented. - `license` (string): The licence the file 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 correction: - `id` (string): The correction's id. It does not change. - `date` (string): The day the correction reached the files. - `kind` (string): Its kind, a code of kinds. - `title` (string): What was wrong, in one line. - `scope` (array of string): The families of files it touched, as the manifest names them without the slash: fund, etf, sec, holders, compare, history, flows, ownership. - `tickers` (array of string): The funds and securities whose figures were wrong, wherever the files list them: every one when tickers_complete is true, examples otherwise. - `tickers_complete` (boolean): Whether tickers lists every fund and security whose figures were wrong. - `before` (string): What the files said, with the figures. - `after` (string): What they say since, with the figures. - `changelog` (string or null): The id of the changelog.json entry that announced it, or null. The same entries are on /contract/. ## 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.