# Endpoints

A section of the TickerInside API reference, https://tickerinside.com/api/#endpoints, 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

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

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

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

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

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

## Errors and redirects

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

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

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


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

## CSV for spreadsheets

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