ETF API: real-time and historical ETF prices for developers

An ETF API gives your code the market prices of exchange-traded funds as JSON: the current bid and ask, the last trade, daily and intraday bars, and a stream of quotes and trades as they change. On TickerLayer the ETF routes live under /etfs, use the same response shapes as stocks, forex and indices, and cover 5,600+ funds under unprefixed codes such as US500ETF and WORLDETF.

What an ETF API does not give you matters just as much. There is no NAV, no intraday indicative value and no holdings file here; those come from each fund. This guide covers symbols, endpoints, real responses and streaming, then shows how to combine market prices with fund data when you need a premium or discount. For the index side of the same exposure, see the indices API guide.

curl -sS "https://api.tickerlayer.com/etfs/quote/US500ETF" \
  -H "x-api-key: $TICKERLAYER_API_KEY"

{"symbol":"US500ETF","bid":767.13,"ask":767.19,"bid_size":100,"ask_size":100,"timestamp":1790591129578}

What an ETF API returns, and what it does not

An ETF has two kinds of data. Market data describes the fund as a traded security: quotes, trades, bars. Fund data describes it as a portfolio: what it holds, what those holdings are worth per share, what it charges. A market data API covers the first kind. NAV, holdings and fees change at most once a day, so they do not need a stream; market data changes constantly, and that is where an API earns its keep.

ETF symbols: alias codes and listing tickers

ETF codes have no market prefix. GET /etfs/symbols returns every code with a name (5,636 rows when we called it), and two naming styles work side by side: generic alias codes that describe the exposure, and the listing ticker of the fund. The docs use aliases, and so do our examples, because an alias says what you are holding without naming a fund issuer.

If you are moving a watchlist over from another tool, paste it into the symbol coverage checker first. It normalizes formats, flags anything outside the catalog, and returns the REST path and stream channel for every match. Then keep the codes unprefixed, exactly as /etfs/symbols returns them.

Endpoints for ETF prices and history

Authenticate with the x-api-key header. ETFs are their own feed: $59 a month on the Individual plan and $549 on Business, with two and ten years of history respectively (pricing). WebSocket comes with paid plans, and free accounts can request a trial from the dashboard. The ETF REST reference lists parameters and error codes.

Anatomy of an ETF quote frame

{
  "type": "quote",
  "channel": "etfs.quotes",1
  "asset": "etfs",
  "symbol": "US500ETF",
  "bid": "767.16",2
  "ask": "767.21",
  "bid_size": "80",3
  "ask_size": "120",
  "ts": 1790591511111,4
  "timestamp": 17905915111115
}

Same channel, same symbol, two encodings less than a second apart. In JavaScript, msg.bid + msg.ask gives 1534.37 on the first frame and the string "767.16767.21" on the second, and nothing throws. Convert every numeric field once, at the edge of your code, and the problem disappears.

Stream ETF quotes and trades in Python

import asyncio
import json
import os
from urllib.parse import quote

import websockets  # pip install websockets

URL = "wss://stream.tickerlayer.com/?apiKey=" + quote(os.environ["TICKERLAYER_API_KEY"], safe="")
SUBSCRIBE = {
    "action": "subscribe",
    "channels": ["etfs.quotes", "etfs.trades"],
    "symbols": ["US500ETF", "US100ETF"],
}


def num(value):
    """ETF frames can carry numbers or numeric strings, even for one symbol."""
    return float(value)


async def main():
    # compression=None: the stream sends uncompressed frames; skip the inflate work.
    async with websockets.connect(URL, compression=None, open_timeout=10) as ws:
        ready = json.loads(await ws.recv())
        if ready.get("event") != "ready":
            raise RuntimeError(f"expected a ready frame, got {ready}")
        await ws.send(json.dumps(SUBSCRIBE))
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") == "quote":
                bid, ask = num(msg["bid"]), num(msg["ask"])
                bps = (ask - bid) / ((ask + bid) / 2) * 10_000
                tag = "  (snapshot)" if msg.get("snapshot") else ""
                print(f'{msg["symbol"]:<9} quote {bid:.2f} / {ask:.2f}  {bps:.2f} bps{tag}')
            elif msg.get("type") == "trade":
                print(f'{msg["symbol"]:<9} trade {num(msg["price"]):.2f} x {num(msg["size"]):g}')
            else:
                print("control:", msg)


if __name__ == "__main__":
    asyncio.run(main())

control: {'type': 'system', 'event': 'subscribed', 'channels': ['etfs.quotes', 'etfs.trades'], 'symbols': ['US100ETF', 'US500ETF']}
US100ETF  quote 737.36 / 737.41  0.68 bps  (snapshot)
US500ETF  quote 767.41 / 767.44  0.39 bps  (snapshot)
US100ETF  trade 737.46 x 40
US500ETF  trade 767.43 x 160
US500ETF  quote 767.39 / 767.43  0.52 bps
US500ETF  trade 767.41 x 40
US500ETF  quote 767.33 / 767.40  0.91 bps

In this pre-market sample the two funds were quoted between 0.39 and 0.91 basis points wide. That column is worth keeping in any ETF screen: the spread is the cost of getting in and out, and on a thinly traded fund one round trip can cost more than a year of its fees. The script stops at the first dropped connection; the WebSocket reconnect guide adds backoff and resubscription.

ETF NAV, premium and discount: the data you add yourself

An ETF's NAV (net asset value) is the value of everything the fund holds, minus liabilities, divided by its shares outstanding. The fund strikes it once a day after the close. The market price trades all day around it, and the gap between the two is the premium (price above NAV) or discount (price below).

Large authorized dealers can create new ETF shares by delivering the underlying basket, or redeem shares for it, so a big premium or discount is an arbitrage they close. That keeps the gap to a few basis points on large funds that hold liquid shares. It opens wider on bond funds, on funds whose underlying markets are shut while the ETF trades, on thin funds, and in stressed markets.

During the session, a calculation agent also publishes an intraday indicative value: a running estimate of NAV from the live prices of the holdings. It is a useful reference for large domestic equity funds. For a fund holding Japanese shares that trades while Tokyo sleeps, the estimate is built on stale prices, and the ETF price itself is often the better real-time read of what the basket is worth.

Holdings files

Holdings are fund data too, so an ETF holdings API is ultimately a wrapper around files the funds publish themselves. Most funds post their full holdings on their own website every business day, and that file is the primary source for look-through views such as sector or country exposure. Holdings change slowly, so one fetch a day is enough; map each holding to a TickerLayer symbol once (for stocks, US:KO style), and price the whole basket from the stream if you need a live look-through value.

A tracking check you can run without NAV

Short of NAV, the cleanest sanity check on ETF data is to compare the fund with the index level it follows. Over a year the two price returns should be close, apart from fees and the timing of dividend payouts. A large gap means you paired the wrong symbols or one of the series has a problem.

import os
import sys

import requests

BASE_URL = "https://api.tickerlayer.com"
session = requests.Session()
session.headers.update({"x-api-key": os.environ["TICKERLAYER_API_KEY"]})


def get(path, params=None):
    resp = session.get(BASE_URL + path, params=params, timeout=15)
    if resp.status_code != 200:
        sys.exit(f"GET {path}: HTTP {resp.status_code} {resp.text[:160]}")
    return resp.json()


def daily_closes(asset, symbol, start, end):
    """{bar start in ms: close} for every daily bar in the range, following pagination."""
    params = {"sort": "asc", "limit": 5000, "offset": 0}
    out = {}
    while True:
        body = get(f"/{asset}/agg/{symbol}/1/day/{start}/{end}", params)
        out.update({bar["t"]: round(bar["c"], 2) for bar in body["results"]})
        if body.get("next_offset") is None:
            return out
        params["offset"] = body["next_offset"]


q = get("/etfs/quote/US500ETF")
mid = (q["bid"] + q["ask"]) / 2
print(f"US500ETF quote {q['bid']} / {q['ask']}, spread {(q['ask'] - q['bid']) / mid * 10_000:.2f} bps")

etf = daily_closes("etfs", "US500ETF", "2025-09-22", "2026-09-25")
idx = daily_closes("indices", "US500", "2025-09-22", "2026-09-25")
days = sorted(etf.keys() & idx.keys())
if len(days) < 2:
    sys.exit("Not enough overlapping sessions to compare.")
a, b = days[0], days[-1]
print(f"{len(days)} sessions in both series")
print(f"US500     {idx[a]:>8.2f} -> {idx[b]:>8.2f}  {idx[b] / idx[a] - 1:+.2%}")
print(f"US500ETF  {etf[a]:>8.2f} -> {etf[b]:>8.2f}  {etf[b] / etf[a] - 1:+.2%}")
ratios = [idx[d] / etf[d] for d in days]
print(f"index / ETF ratio ranged {min(ratios):.3f} to {max(ratios):.3f}")

US500ETF quote 767.13 / 767.19, spread 0.78 bps
255 sessions in both series
US500      6693.75 ->  7743.41  +15.68%
US500ETF    666.84 ->   771.35  +15.67%
index / ETF ratio ranged 10.008 to 10.088

The ratio between the index level and the fund's price drifts slowly, from 10.008 to 10.088 over the year. Each fund picks its own starting share price, and dividends the fund has collected but not yet paid out build up in its price between distributions. That drift is a property of the fund, not an error in either series. ETF vs index fund looks at the same pair minute by minute through one session.

Where ETF prices fit in a product

• Portfolio trackersValue holdings at the last trade or the mid, and show the spread so users see the cost of selling.
• BacktestsDaily bars back to the start of your plan's history. The golden cross backtest shows the pattern on an index.
• Fund against indexChart an ETF next to the level it tracks. How a stock index is built explains why the weighting matters.
• Research datasetsPull years of bars in pages of up to 5,000. Historical stock data covers adjustments, session boundaries and export.

Build notes