# GET /api/v1/sec/{ticker}.json

One endpoint of the TickerInside API, 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

`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

## Response

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.

## Errors and redirects

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