# TickerInside ETF Holdings (remote · tickerinside.com)

US ETF and mutual fund holdings, which ETFs hold a stock, overlap, look-through. Free, no API key.

- Trust score: 73/100 (medium)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-06

## Components

- remote · `tickerinside.com`: 73/100 (this document), [markdown](https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside.md), [page](https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside)
- npm · `tickerinside-mcp`: 61/100, [markdown](https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside-mcp.md), [page](https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside-mcp)

## Channel facts

- Endpoint: `https://tickerinside.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.14.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-06.

- **Endpoint Security**: 74/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Nothing on it is marked destructive, but we can't show that an anonymous caller can only read: full credit needs the server to list at least one tool and every tool to be verifiably read-only. We use a best-effort check of tool names and descriptions to tell read-only tools from tools that change things, so some genuinely read-only tools may not get full credit. Names that start with a read verb (get, list, read, search and similar) and accurate readOnlyHint annotations help. Meet that to earn full credit, or require authorisation.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4197 tokens (~246/item across 17 items; 13 tools + 4 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 9/100
  - Stability check failed: schema churn in the 30 days we've observed: 10 tool removals, 0 breaking changes, 0 auth/transport breaks, 12 additions.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 13 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 15 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).
  - Supports UI / widget rendering.

## Install

### How do I install the TickerInside ETF Holdings MCP server?

TickerInside ETF Holdings is a hosted endpoint at https://tickerinside.com/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

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

### Cursor

```json
{
  "mcpServers": {
    "com-tickerinside-tickerinside-mcp": {
      "url": "https://tickerinside.com/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-tickerinside-tickerinside-mcp": {
      "type": "http",
      "url": "https://tickerinside.com/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-tickerinside-tickerinside-mcp]
url = "https://tickerinside.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-tickerinside-tickerinside-mcp": {
      "type": "remote",
      "url": "https://tickerinside.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-tickerinside-tickerinside-mcp --url 'https://tickerinside.com/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-tickerinside-tickerinside-mcp:
    url: "https://tickerinside.com/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "com-tickerinside-tickerinside-mcp": {
      "Transport": "http",
      "Url": "https://tickerinside.com/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-tickerinside-tickerinside-mcp -t streamable-http -u 'https://tickerinside.com/mcp'
```

### Other

```json
{
  "mcpServers": {
    "com-tickerinside-tickerinside-mcp": {
      "type": "http",
      "url": "https://tickerinside.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-06 (score 73, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-11-05 (score 73, 0)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-11-04 (score 73, 0)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-10-30 (score 73, 0)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-10-29 (score 73, 0)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-10-28 (score 73, 0)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-10-25 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 6 to 9.

### 2026-10-23 (score 72, +1)

- [security] The server rewrote its instructions, which are the text every model session reads

## MCP tools (13)

### `list_etfs` (~320 tokens)

Coverage and ETF search

Use this when the user asks whether a US ETF is covered, wants to find an ETF by name or ticker, or asks how many ETFs the data covers and how recent it is. Returns the date of the data and the count of covered ETFs by source: the issuers' own holdings files, SEC Form N-PORT filings, trusts' filings, sponsors' files and prospectuses, and how many of the US-listed ETFs that is. With query, it returns up to 50 matching ETFs with their names, sources and categories; without query, it also lists every covered ticker by source unless include_tickers is false, a long answer. Mutual funds, closed-end funds and funds listed outside the US are not covered. Not for an ETF's holdings or figures (get_etf_holdings).

Input parameters:

- `include_tickers` (boolean): Whether an answer without query lists every covered ticker, by source, and only those of source when it is given. true or left out adds the lists, a long answer; false returns the counts and dates al…
- `query` (string): A ticker or words from an ETF's name, for example VOO or semiconductor. Case does not matter.
- `source` (string): Only the ETFs read from the issuers' own files, only the stock ETFs from SEC filings, only the fixed income ETFs, only the multi-asset ETFs, only the derivative-based ETFs, only the trusts and pools,…

Output parameters:

- `as_of` (string|null)
- `funds_by_source` (object)
- `funds_covered` (integer|null)
- `issuers` (array)
- `match_count` (integer|null)
- `matches` (array)
- `source` (object)
- `us_listed_etfs` (object)

### `get_etf_holdings` (~291 tokens)

ETF holdings and profile

Use this when the user asks what a US ETF or mutual fund holds or its sectors, cost, size, returns and risk. Returns the holdings largest first with their weights, category, sector, mega-cap tech and country weights, expense ratio, assets, top 10 weight, 1, 3 and 5-year returns, volatility, beta and worst fall, with each file's date; most ETFs read from SEC filings have no return or risk figures here. Returns are past, not a forecast. A bond ETF gives its lines by issuer, coupon and maturity, with duration; an ETF read from SEC filings that is leveraged, inverse, under half in stock or half in swaps and futures lists its shares, and its contracts apart as notional exposure; an option income ETF read as a stock ETF (JEPI, QYLD) lists its stocks, not its options or notes; a trust what its filing says it holds; a prospectus-only ETF its objective. Not for comparing ETFs (compare_etfs) or the ETFs holding a stock (find_etfs_holding_stock).

Input parameters:

- `holdings` (integer): How many of the largest holdings to return, from 0 to 500; 25 when left out. 0 returns the figures without holdings.
- `ticker` (string, required): A US ETF ticker, for example VOO or SCHD. Case does not matter.

Output parameters:

- `aum_billions` (number|null): In billions of US dollars.
- `beta_vs_sp500` (number|null)
- `breakdown` (object)
- `category` (object|null)
- `covered` (boolean)
- `expense_ratio_pct` (number|null)
- `holdings` (array)
- `holdings_as_of` (string|null)
- `holdings_source` (string)
- `name` (string|null)
- `not_covered` (array)
- `positions` (integer|null)
- `prices_as_of` (string|null)
- `return_1y_pct` (number|null)
- `return_3y_pct` (number|null)
- `return_5y_pct` (number|null)
- `source` (object)
- `ticker` (string)
- `top_10_weight_pct` (number|null)
- `volatility_pct` (number|null)
- `worst_fall_3y_pct` (number|null)

### `compare_etfs` (~251 tokens)

Overlap and risk of two ETFs

Use this when the user names exactly two US ETFs and asks how much they overlap, whether one duplicates the other, or how they differ in cost and risk. Returns the overlap by weight and each ETF's share held in common, the largest shared holdings, the correlation of weekly returns over up to three years, and each ETF's cost, return, volatility and worst fall (most ETFs read from SEC filings have no return or risk figures here), with both holdings dates. Two bond ETFs are compared by issuer overlap, option income stock ETFs (JEPI, QYLD) by their stocks alone. An ETF read from SEC filings that is leveraged, inverse, under half in stock or half in swaps and futures, a trust or pool (metal, crypto, currency, futures), a multi-asset, sponsor-file or prospectus-only ETF, or a bond ETF beside a stock ETF is compared by weekly returns alone, with the reason. Not for three or more ETFs (get_etf_overlap_matrix).

Input parameters:

- `a` (string, required): A US ETF ticker, for example VOO or SCHD. Case does not matter.
- `b` (string, required): The other US ETF ticker, for example QQQ.

Output parameters:

- `comparable` (boolean)
- `correlation_3y` (number|null)
- `covered` (boolean)
- `funds` (object)
- `holdings_as_of` (object)
- `holdings_source` (object)
- `issuer_overlap` (object): By issuer, in percent.
- `not_comparable` (array)
- `not_covered` (array)
- `overlap` (object): In percent.
- `pair` (array)
- `prices_as_of` (string|null)
- `source` (object)
- `weeks_used` (integer|null)

### `get_etf_overlap_matrix` (~244 tokens)

Overlap across many ETFs

Use this when the user lists three to thirty US ETFs, often a portfolio, and asks which of them duplicate each other or whether the list is diversified across companies; two give one pair. Returns every pair ranked by overlap by weight, with the share of each ETF held in common and the count of companies in both, and the holdings date and source of each ETF in those pairs. It measures diversification by the holdings the ETFs share, not by how their returns move together. Bond ETFs are paired by issuer overlap and listed apart. Uncovered tickers are named and skipped; commodity, multi-asset, sponsor-file and prospectus-only ETFs and ETFs read from SEC filings that are leveraged, inverse, under half in stock or half in swaps and futures are listed as not comparable, each with its reason. Not for the companies underneath (get_etf_portfolio_lookthrough) or how ETFs move together (get_etf_portfolio_risk).

Input parameters:

- `tickers` (array, required): 2 to 30 US ETF tickers, for example ["VOO", "QQQ", "SCHD"]: three or more give the matrix, two give one pair.

Output parameters:

- `computed` (boolean)
- `covered` (boolean)
- `holdings_as_of` (object)
- `holdings_source` (object)
- `issuer_overlap_pairs` (array): By issuer, in percent, largest first.
- `not_comparable` (array)
- `not_covered` (array)
- `pairs` (array): In percent, largest first.
- `prices_as_of` (string|null)
- `skipped` (object)
- `source` (object)

### `get_etf_portfolio_lookthrough` (~364 tokens)

Companies inside a portfolio

Use this when the user gives a portfolio of US ETFs and asks which companies they own, how much of one company they hold, or how concentrated it is. Returns the companies underneath, each with its percent of what is looked through, its value when amounts are given and the ETFs it comes through, plus the count of holdings, by ticker, and the top 10 weight; for one company, raise top until it shows, up to 200. It measures diversification by single companies, not by how ETFs move together. Without amounts, every ETF counts equally. Uncovered tickers (US stocks among them), bond, commodity, multi-asset, sponsor-file and prospectus-only ETFs, and ETFs read from SEC filings that are leveraged, inverse, under half in stock or half in swaps and futures are named and left out of the percentages and the value. Amounts are not stored. Not for duplicate ETFs (get_etf_overlap_matrix) or risk (get_etf_portfolio_risk).

Input parameters:

- `currency` (string): The currency of the amounts, for example USD or EUR. Echoed back with the values; nothing is converted. Left out, the amounts still weigh the ETFs and the currency reads unstated.
- `positions` (array, required): The ETFs of the portfolio, 1 to 60, for example [{"ticker": "VOO", "amount": 40000}, {"ticker": "QQQ", "amount": 25000}] with "currency": "USD" beside it. Give an amount for every position or for non…
- `top` (integer): How many companies to return, largest first, from 1 to 200; 25 when left out.

Output parameters:

- `companies` (array): Largest first; value in the amounts' currency.
- `computed` (boolean)
- `covered` (boolean)
- `currency` (string|null)
- `distinct_companies` (integer|null)
- `funds` (integer|null)
- `holdings_as_of` (object)
- `holdings_source` (object)
- `looked_through_pct` (number|null)
- `not_covered` (array)
- `not_looked_through` (array)
- `portfolio_value` (number|null)
- `priced` (boolean)
- `prices_as_of` (string|null)
- `skipped` (object)
- `source` (object)
- `top_10_weight_pct` (number|null)

### `get_etf_portfolio_risk` (~314 tokens)

Portfolio risk breakdown

Use this when the user gives a portfolio of US ETFs and asks where its risk comes from or how its ETFs move together. Returns the portfolio's volatility, each position's share of the risk and of the capital, the diversification ratio, independent bets, the beta to the S&P 500, and the correlation and covariance of weekly returns over up to three years. It measures diversification by how the ETFs move together, not by companies held. Every ETF needs a year of weekly prices, which most ETFs read from SEC filings do not have here. Uncovered tickers are named and skipped. A trust or pool (bitcoin, gold), a bond, multi-asset or leveraged, inverse or other derivative-based ETF counts from its own weekly prices when it has them, named in read_from_prices. Past, not a forecast. Not for the companies held (get_etf_portfolio_lookthrough).

Input parameters:

- `currency` (string): The currency of the amounts, for example USD or EUR. Echoed back with the values; nothing is converted. Left out, the amounts still weigh the ETFs and the currency reads unstated.
- `positions` (array, required): The ETFs of the portfolio, 1 to 60, for example [{"ticker": "VOO", "amount": 40000}, {"ticker": "QQQ", "amount": 25000}] with "currency": "USD" beside it. Give an amount for every position or for non…

Output parameters:

- `beta_vs_sp500_1y` (number|null)
- `beta_vs_sp500_3y` (number|null)
- `computed` (boolean)
- `correlation` (object): Weekly returns; rows in the order of labels.
- `covered` (boolean)
- `currency` (string|null)
- `diversification_ratio` (number|null)
- `holdings_as_of` (object)
- `holdings_source` (object)
- `independent_bets` (number|null)
- `not_covered` (array)
- `positions` (array)
- `prices_as_of` (string|null)
- `read_from_prices` (array)
- `skipped` (object)
- `source` (object)
- `volatility_pct` (number|null): Annualised.
- `weeks_used` (integer|null)

### `find_etfs_holding_stock` (~557 tokens)

ETFs that hold a stock

Use this when the user asks which ETFs hold a stock, which ETF holds the most of it, how many ETFs hold it, or whether it is in VOO, SPY, IVV, QQQ, VTI or SCHD. Returns the covered US ETFs that hold it, largest weight first, each with its weight, rank, dollars, holdings date and source, plus the count, how many hold it as their largest position, the ETFs and issuers with the most dollars in it, and one sentence to quote. The list keeps the heaviest holders; whether the six ETFs above hold it is in every answer for a stock with its own file, unless compact is true. ETFs holding it through swaps, futures or options are listed apart, as notional exposure. A private company's name in place of a ticker (ANTHROPIC, OPENAI) gives the US funds holding it, each stake and value per share from its SEC filing. Not for one stock's weight in another ETF (compare_stocks) or the share ETFs own (get_etf_ownership).

Input parameters:

- `compact` (boolean): true for an answer about half the length. It keeps the counts, rank_summary (how many ETFs hold the stock as their largest or a top 10 position), name_collision (ETFs whose name contains the company'…
- `ticker` (string, required): The stock's ticker, not the company name, for example NVDA for Nvidia. A line listed outside the US carries its market after a dot, for example 7203.JP (Toyota in Tokyo), SAN.FR (Sanofi in Paris) or…
- `top` (integer): How many ETFs to return, sorted by the stock's weight in each ETF, largest first, from 1 to 200; 50 when left out.

Output parameters:

- `answer` (string|null): One sentence to quote.
- `funds_by_source` (object)
- `funds_holding` (integer|null)
- `held` (boolean)
- `held_by` (array): Largest weight first.
- `membership` (array|null)
- `name` (string|null)
- `rank_summary` (object|null)
- `source` (object)
- `ticker` (string)

### `compare_stocks` (~248 tokens)

Stock comparison and weight in an ETF

Use this when the user asks how two US stocks compare on size, valuation, returns, risk or correlation, or what weight and rank one stock has inside one named ETF, for example META in QQQ. For two stocks it returns market cap, P/E and dividend yield from market data, returns, volatility, worst fall, beta, the correlation of weekly returns over up to three years and the covered ETFs holding both. For a stock and an ETF it returns whether the ETF holds the stock, at what weight and rank among the shares it holds outright, with the date of the ETF's holdings; a derivative-based ETF's swaps, futures and options are in its profile (get_etf_holdings), not here. A stock is in the data with about two years of US prices, and sooner for a recent listing a covered ETF holds. Returns are past, not a forecast. Not for comparing two ETFs (compare_etfs), or a company's business or products.

Input parameters:

- `a` (string, required): A US stock ticker, for example NVDA. An ETF ticker also works on one side, for example QQQ.
- `b` (string, required): The other ticker, for example AMD.

Output parameters:

- `correlation_3y` (number|null)
- `covered` (boolean)
- `funds_holding_both` (array)
- `funds_holding_both_count` (integer|null)
- `membership` (object): For a stock and an ETF.
- `not_in_data` (array)
- `pair` (array)
- `prices_as_of` (string|null)
- `source` (object)
- `weeks_used` (integer|null)

### `get_etf_ownership` (~187 tokens)

ETF ownership of a stock

Use this when the user asks how much of a US company ETFs own, or what share of its stock sits in ETFs. Returns a lower bound: at least this percent of the shares outstanding is held by the covered US ETFs, from this many ETFs, with the shares held, the SEC's count of shares outstanding and its date, the holdings dates, the method, whether the percent is of the whole company or of the ticker's class, and where the figure ranks among the stocks measured. It is a lower bound because ETFs outside the coverage are not counted. A stock without a figure comes back with the reason. Not for the list of ETFs that hold the stock (find_etfs_holding_stock).

Input parameters:

- `ticker` (string, required): A US stock ticker, for example NVDA or BRK.B. BRK-B and BRK/B are read as BRK.B.

Output parameters:

- `basis` (string|null): company when every class is counted, class when the ticker's class alone is.
- `covered` (boolean)
- `etf_ownership_pct_at_least` (number|null): The percent of the shares outstanding held by the covered US ETFs, at least.
- `figure` (boolean)
- `holdings_as_of` (object|null)
- `market` (object|null)
- `name` (string|null)
- `shares_held_by_covered_etfs` (number|null)
- `shares_outstanding` (number|null)
- `shares_outstanding_as_of` (string|null)
- `source` (object)
- `ticker` (string)

### `get_etf_holdings_history` (~260 tokens)

ETF holdings history

Use this when the user asks how a US ETF's holdings evolved over time, what it held in a past year or quarter, how often its holdings file changes, or how its overlap with its closest ETFs moved. For the US ETFs that report their stock holdings to the SEC, returns each quarterly Form N-PORT report since 2019 with its date, filing, position count, top 10 weight and five largest positions, and the address of every position at a date. For the stock ETFs read from their issuers' own files, also returns each archived file date (from 1 September 2026) with its position count and top 10 weight, each step's entered, exited and moved counts and turnover, and the overlap by weight with its ten closest ETFs; a step across a change in how the files are read is marked restated. Not for the lines one step added or dropped (get_etf_holdings_changes).

Input parameters:

- `since` (string): Only the steps to a file dated on or after this date, written YYYY-MM-DD, for example 2026-09-15.
- `ticker` (string, required): A US ETF ticker, for example VOO or SCHD. Case does not matter.

Output parameters:

- `cadence` (string|null)
- `covered` (boolean)
- `file_dates` (integer|null)
- `files` (array): Oldest first.
- `first_file` (string|null)
- `history` (boolean)
- `last_file` (string|null)
- `name` (string|null)
- `overlap_by_weight_pct` (object)
- `source` (object)
- `steps` (array): Oldest first.
- `ticker` (string)

### `get_etf_holdings_changes` (~277 tokens)

ETF holdings changes

Use this when the user asks what a US ETF bought, sold, added or dropped, or how the weights of its holdings changed, recently or since a date. Returns, for each step from one issuer file to the next, the lines that entered and exited with their weights and the lines whose weight moved by 0.05 points or more, before and after, which includes price moves and not only trades, with the turnover measures; the latest step when no date is given. Kept for the stock ETFs read daily from their issuers' own files; another ETF comes back with the reason it has no history. A step across a change in how the files are keyed or read is marked restated and lists no trades. Not for an ETF's holdings on one date (get_etf_holdings) or its overlap over time (get_etf_holdings_history).

Input parameters:

- `limit` (integer): The most lines listed in each of entered, exited and moved for one step, largest first. The counts are always whole.
- `since` (string): Only the steps to a file dated on or after this date, written YYYY-MM-DD, for example 2026-09-15.
- `ticker` (string, required): A US ETF ticker, for example VOO or SCHD. Case does not matter.

Output parameters:

- `covered` (boolean)
- `first_file` (string|null)
- `history` (boolean)
- `last_file` (string|null)
- `moved_threshold_pp` (number|null)
- `name` (string|null)
- `source` (object)
- `steps` (array): Oldest first; each step's lines largest first.
- `ticker` (string)

### `get_etf_flows` (~280 tokens)

ETF buying and selling

Use this when the user asks how much money went into or out of US ETFs or one ETF, whether ETFs are buying or selling a stock, or which stocks entered or left an index fund. Without a ticker, returns the day's ETF inflows and outflows and the largest net additions and reductions of stocks. With an ETF's ticker (QQQ), its net creations and redemptions in dollars on each of the last 20 closes. With a stock's ticker, the net change in shares held by the US ETFs read daily from their issuers' files on the latest market close, its value at the files' own prices, the ETFs that added and trimmed, a 20-close series, index entries and exits and corporate actions. A change mixes creations of the ETFs' own shares with rebalancing; beyond_growth leaves out the first. Mergers, spin-offs and splits are no trades: left out of the sums. Not for which ETFs hold a stock (find_etfs_holding_stock) or one ETF's holdings changes (get_etf_holdings_changes).

Input parameters:

- `ticker` (string): An ETF ticker for its own money flows, for example QQQ, or a stock ticker, for example NVDA, or a line listed abroad such as 7203.JP. Leave it out for the day's flows.

Output parameters:

- `added_by_value` (array)
- `corporate_actions` (array)
- `covered` (boolean)
- `date` (string|null): The market close of the figures.
- `how_to_quote` (string)
- `index_events` (array)
- `latest` (object|null)
- `reduced_by_value` (array)
- `series` (array)
- `ticker` (string)

### `find_diversifying_etfs` (~278 tokens)

ETFs that diversify a portfolio

Use this when the user asks which ETFs would diversify an ETF or a portfolio of ETFs, what could be added to diversify it, or which ETFs moved least with what they hold. Ranks a fixed, published list of 30 large US ETFs across six kinds of exposure (US, sector, international and emerging market stocks, bonds and commodities) by the correlation of their weekly returns with the portfolio's over up to three years, and returns the ETF of lowest correlation in each of the three groups whose lowest is lowest, with its correlation on the weeks the portfolio fell, the portfolio's volatility with 10% in it and its overlap by weight, then the next ETFs of the list. Takes 1 to 6 ETFs held. A measurement of past co-movement, not investment advice; every answer carries that note. Not for the overlap of ETFs the user names (compare_etfs, get_etf_overlap_matrix) or the risk of the portfolio itself (get_etf_portfolio_risk).

Input parameters:

- `positions` (array, required): The ETFs held, 1 to 6, for example [{"ticker": "VOO", "amount": 60000}, {"ticker": "QQQ", "amount": 20000}]. Give an amount for every position or for none; with none, every ETF counts equally.

Output parameters:

- `answer` (string)
- `covered` (boolean)
- `lowest` (array)
- `note` (string)
- `page_url` (string|null)
- `question` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside#diagnostics

## Score history

- 2026-11-06: 73
- 2026-11-05: 73
- 2026-11-04: 73
- 2026-11-03: 73
- 2026-11-02: 73
- 2026-11-01: 73
- 2026-10-31: 73
- 2026-10-30: 73
- 2026-10-29: 73
- 2026-10-28: 73
- 2026-10-27: 73
- 2026-10-26: 73
- 2026-10-25: 73
- 2026-10-24: 72
- 2026-10-23: 72
- 2026-10-22: 71
- 2026-10-21: 71
- 2026-10-20: 71
- 2026-10-19: 71
- 2026-10-18: 71
- 2026-10-17: 71
- 2026-10-16: 71
- 2026-10-15: 71
- 2026-10-14: 71
- 2026-10-13: 71
- 2026-10-12: 71
- 2026-10-10: 71
- 2026-10-05: 73
- 2026-10-04: 73
- 2026-10-03: 73

## Common questions

### What is the TickerInside ETF Holdings MCP server?

TickerInside ETF Holdings is an MCP server listed in the public MCP registry as com.tickerinside/tickerinside-mcp. US ETF and mutual fund holdings, which ETFs hold a stock, overlap, look-through. Free, no API key. This page covers its hosted endpoint (https://tickerinside.com/mcp).

### Is the TickerInside ETF Holdings MCP server safe to use?

TickerInside ETF Holdings scores 73 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the TickerInside ETF Holdings MCP server expose?

TickerInside ETF Holdings exposes 13 tools: list_etfs, get_etf_holdings, compare_etfs, get_etf_overlap_matrix, get_etf_portfolio_lookthrough, and 8 more. Their descriptions and schemas cost roughly 3,871 tokens of context every time the server is loaded.

### Does the TickerInside ETF Holdings MCP server require authentication?

No. We connected to TickerInside ETF Holdings without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the TickerInside ETF Holdings MCP server still maintained?

TickerInside ETF Holdings is still listed as active in the MCP registry. We last reached this channel on 6 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the TickerInside ETF Holdings MCP server?

VerifyMCP ran 14 checks on TickerInside ETF Holdings, covering TLS certificate, Authorization, HTTPS, HSTS header and 10 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://tickerinside.com/mcp
- Website: https://tickerinside.com/agent/
- Changelog RSS feed: https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside.json
- HTML version of this page: https://verifymcp.io/servers/com-tickerinside-tickerinside-mcp/tickerinside