# GET /api/v1/fund/{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 /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

## Response

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.

## 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 | `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 | `not_in_directory` | Under `/fund/`: not covered, nor in the directory of US-listed funds; a listed one gets its `universe.json` code. | `covered`: `index.json`, which lists every covered fund. |
| 404 | `no_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`.