DTF pricing API

import requests

BASE = "https://prices.indexes.fi"

health = requests.get(f"{BASE}/health", timeout=10).json()

print(health["feed"])          # live | connecting | rejected | stopped
print(health["dtfs"])          # DTFs being priced
print(health["instruments"])   # distinct upstream instruments subscribed
print(health["marks"])         # instruments with at least one mark

# "ok" alone is not enough. A feed that authenticated and subscribed to
# nothing also answers ok, so check that it is actually watching something.
assert health["feed"] == "live" and health["marks"] > 0

const BASE = 'https://prices.indexes.fi'

const health = await fetch(`${BASE}/health`).then((r) => r.json())

console.log(health.feed)         // live | connecting | rejected | stopped
console.log(health.dtfs)         // DTFs being priced
console.log(health.instruments)  // distinct upstream instruments subscribed
console.log(health.marks)        // instruments with at least one mark

// "ok" alone is not enough. A feed that authenticated and subscribed to
// nothing also answers ok, so check that it is actually watching something.
if (health.feed !== 'live' || health.marks === 0) {
  throw new Error('Pricing service is up but not watching anything.')
}

import { useEffect, useState } from 'react'

const BASE = 'https://prices.indexes.fi'

export function usePricingHealth(intervalMs = 30_000) {
  const [health, setHealth] = useState(null)

  useEffect(() => {
    let cancelled = false

    const check = async () => {
      try {
        const res = await fetch(`${BASE}/health`, { cache: 'no-store' })
        const body = await res.json()
        if (!cancelled) setHealth(body)
      } catch {
        if (!cancelled) setHealth({ feed: 'offline' })
      }
    }

    void check()
    const timer = setInterval(check, intervalMs)
    return () => {
      cancelled = true
      clearInterval(timer)
    }
  }, [intervalMs])

  return health
}

import requests

BASE = "https://prices.indexes.fi"

# The collection is an array. There is no envelope to reach through.
dtfs = requests.get(f"{BASE}/v1/dtfs", timeout=10).json()

for dtf in dtfs:
    # Each leg carries its weight and its current mark together.
    legs = ", ".join(f"{leg['symbol']} {leg['weightPct']}% @ {leg['price']}" for leg in dtf["legs"])
    price = dtf["price"]["price"] if dtf["price"] else None
    print(f"{dtf['shareSymbol']:8} {dtf['slug']:32} {legs:24} {price}")

    # A leg the service cannot mark is named, not silently dropped.
    if dtf["unpriceableSymbols"]:
        print(f"  not priced: {dtf['unpriceableSymbols']}")

const BASE = 'https://prices.indexes.fi'

// The collection is an array. There is no envelope to reach through.
const dtfs = await fetch(`${BASE}/v1/dtfs`).then((r) => r.json())

for (const dtf of dtfs) {
  // Each leg carries its weight and its current mark together.
  const legs = dtf.legs.map((leg) => `${leg.symbol} ${leg.weightPct}% @ ${leg.price}`).join(', ')
  console.log(dtf.shareSymbol, dtf.slug, legs, dtf.price?.price ?? 'awaiting marks')

  // A leg the service cannot mark is named, not silently dropped.
  if (dtf.unpriceableSymbols.length > 0) {
    console.warn(`${dtf.shareSymbol} excludes ${dtf.unpriceableSymbols.join(', ')}`)
  }
}

import { useEffect, useState } from 'react'

const BASE = 'https://prices.indexes.fi'

export function DtfList() {
  const [dtfs, setDtfs] = useState([])

  useEffect(() => {
    let cancelled = false
    fetch(`${BASE}/v1/dtfs`)
      .then((r) => r.json())
      .then((list) => {
        if (!cancelled) setDtfs(list)
      })
    return () => {
      cancelled = true
    }
  }, [])

  return (
    <ul>
      {dtfs.map((dtf) => (
        <li key={dtf.id}>
          <a href={`/${dtf.slug}`}>{dtf.name}</a>{' '}
          {dtf.price ? dtf.price.price.toFixed(4) : 'awaiting marks'} USDC
        </li>
      ))}
    </ul>
  )
}

import requests

BASE = "https://prices.indexes.fi"
KEY = "ixda-dtf-btc-eth-50-50"   # slug, share symbol, or DTF id

res = requests.get(f"{BASE}/v1/dtfs/{KEY}", timeout=10)

if res.status_code == 404:
    raise SystemExit(f"No DTF matches {KEY}")

# The resource is the body.
dtf = res.json()

print(dtf["name"], dtf["shareSymbol"])
print("created", dtf["createdAt"])
print("rebalances every", dtf["rebalanceCadenceHours"], "hours")
for leg in dtf["legs"]:
    flag = " STALE" if leg["stale"] else ""
    print(" ", leg["symbol"], leg["feedSymbol"], leg["weightPct"], "%", leg["price"], flag)

# The current price comes embedded, so one request is enough.
print("price", dtf["price"]["price"] if dtf["price"] else "awaiting marks")

const BASE = 'https://prices.indexes.fi'
const KEY = 'ixda-dtf-btc-eth-50-50'   // slug, share symbol, or DTF id

const res = await fetch(`${BASE}/v1/dtfs/${encodeURIComponent(KEY)}`)
if (res.status === 404) throw new Error(`No DTF matches ${KEY}`)

// The resource is the body, with its current price embedded.
const dtf = await res.json()

console.log(dtf.name, dtf.shareSymbol)
console.log('created', dtf.createdAt)
console.log('rebalances every', dtf.rebalanceCadenceHours, 'hours')
for (const leg of dtf.legs) {
  console.log(' ', leg.symbol, leg.feedSymbol, leg.weightPct + '%', leg.price, leg.stale ? 'STALE' : '')
}
console.log('price', dtf.price?.price ?? 'awaiting marks')

import { useEffect, useState } from 'react'

const BASE = 'https://prices.indexes.fi'

export function useDtf(key) {
  const [state, setState] = useState({ dtf: null, status: 'loading' })

  useEffect(() => {
    let cancelled = false
    fetch(`${BASE}/v1/dtfs/${encodeURIComponent(key)}`)
      .then((r) => (r.ok ? r.json() : Promise.reject(new Error(String(r.status)))))
      .then((dtf) => {
        if (!cancelled) setState({ dtf, status: 'ready' })
      })
      .catch(() => {
        if (!cancelled) setState({ dtf: null, status: 'unavailable' })
      })
    return () => {
      cancelled = true
    }
  }, [key])

  return state
}

import requests

BASE = "https://prices.indexes.fi"
KEY = "ixda-dtf-btc-eth-50-50"

# The path already named the DTF, so the body is the price on its own.
price = requests.get(f"{BASE}/v1/dtfs/{KEY}/price", timeout=10).json()

# price=None means the service is up and this DTF has not had every leg
# print yet. It is not an error and retrying will not change it; only a
# trade will.
if price["price"] is None:
    raise SystemExit(price.get("reason", "AWAITING_MARKS"))

print(price["price"])       # index level, 1.0 at the DTF's creation
print(price["returnBps"])   # return since creation, basis points
print(price["observedAt"])  # when the venue timestamped the trade

# Always read this. A price built on a stale leg is not wrong, but it is not
# the index either, and a stale leg looks identical to a flat market.
stale = [leg["symbol"] for leg in price["legs"] if leg["stale"]]
if stale:
    print("stale legs:", stale)

for leg in price["legs"]:
    print(" ", leg["symbol"], leg["price"], "age(ms)", leg["markAgeMs"])

const BASE = 'https://prices.indexes.fi'
const KEY = 'ixda-dtf-btc-eth-50-50'

// The path already named the DTF, so the body is the price on its own.
const price = await fetch(
  `${BASE}/v1/dtfs/${encodeURIComponent(KEY)}/price`,
).then((r) => r.json())

// price=null means the service is up and this DTF has not had every leg
// print yet. It is not an error and retrying will not change it; only a
// trade will.
if (price.price === null) throw new Error(price.reason ?? 'AWAITING_MARKS')

console.log(price.price)       // index level, 1.0 at the DTF's creation
console.log(price.returnBps)   // return since creation, basis points
console.log(price.observedAt)  // when the venue timestamped the trade

// Always read this. A price built on a stale leg is not wrong, but it is not
// the index either, and a stale leg looks identical to a flat market.
const stale = price.legs.filter((leg) => leg.stale).map((leg) => leg.symbol)
if (stale.length > 0) console.warn('stale legs:', stale.join(', '))

import { useEffect, useState } from 'react'

const BASE = 'https://prices.indexes.fi'

/** Polling fallback. Prefer the WebSocket below; this is for when one is not
 *  available, or for a page that only needs an occasional number. */
export function usePolledDtfPrice(key, intervalMs = 15_000) {
  const [price, setPrice] = useState(null)

  useEffect(() => {
    let cancelled = false

    const read = async () => {
      const body = await fetch(
        `${BASE}/v1/dtfs/${encodeURIComponent(key)}/price`,
        { cache: 'no-store' },
      ).then((r) => r.json())
      if (!cancelled) setPrice(body.price === null ? null : body)
    }

    void read()
    const timer = setInterval(read, intervalMs)
    return () => {
      cancelled = true
      clearInterval(timer)
    }
  }, [key, intervalMs])

  const stale = (price?.legs ?? []).filter((leg) => leg.stale).map((leg) => leg.symbol)

  return { price, stale }
}

import requests
from datetime import datetime, timezone

BASE = "https://prices.indexes.fi"
KEY = "ixda-dtf-btc-eth-50-50"

body = requests.get(
    f"{BASE}/v1/dtfs/{KEY}/candles",
    params={"days": 90},
    timeout=30,
).json()

# Read this rather than assuming five minutes. The service coarsens long
# windows so the series always spans the days you asked for; what varies
# is how finely.
print("resolution", body["resolutionMinutes"], "minutes")
print("bars", len(body["candles"]))

for bar in body["candles"][-5:]:
    when = datetime.fromtimestamp(bar["t"], tz=timezone.utc)
    print(when.isoformat(), bar["o"], bar["h"], bar["l"], bar["c"], bar["source"])

# source distinguishes bars observed tick by tick from bars reconstructed
# out of upstream aggregates. A flat run of each means different things.
observed = [b for b in body["candles"] if b["source"] == "live"]
print(f"{len(observed)} of {len(body['candles'])} bars observed here")

# Force the stored granularity for a short window.
fine = requests.get(
    f"{BASE}/v1/dtfs/{KEY}/candles",
    params={"days": 1, "resolutionMinutes": 5},
    timeout=30,
).json()
print("fine bars", len(fine["candles"]))

const BASE = 'https://prices.indexes.fi'
const KEY = 'ixda-dtf-btc-eth-50-50'

const url = new URL(`${BASE}/v1/dtfs/${encodeURIComponent(KEY)}/candles`)
url.searchParams.set('days', '90')

const body = await fetch(url).then((r) => r.json())

// Read this rather than assuming five minutes. The service coarsens long
// windows so the series always spans the days you asked for; what varies
// is how finely.
console.log('resolution', body.resolutionMinutes, 'minutes')
console.log('bars', body.candles.length)

for (const bar of body.candles.slice(-5)) {
  console.log(new Date(bar.t * 1000).toISOString(), bar.o, bar.h, bar.l, bar.c, bar.source)
}

// source distinguishes bars observed tick by tick from bars reconstructed
// out of upstream aggregates. A flat run of each means different things.
const observed = body.candles.filter((bar) => bar.source === 'live')
console.log(`${observed.length} of ${body.candles.length} bars observed here`)

import { useEffect, useMemo, useState } from 'react'

const BASE = 'https://prices.indexes.fi'

export function useDtfCandles(key, days) {
  const [series, setSeries] = useState(null)

  useEffect(() => {
    let cancelled = false
    const url = new URL(`${BASE}/v1/dtfs/${encodeURIComponent(key)}/candles`)
    url.searchParams.set('days', String(days))

    fetch(url, { cache: 'no-store' })
      .then((r) => r.json())
      .then((body) => {
        if (!cancelled) setSeries(body)
      })

    // Refetch so newly closed bars land. The open bar is already included in
    // every response, so the chart is never more than a tick behind.
    const timer = setInterval(() => {
      fetch(url, { cache: 'no-store' })
        .then((r) => r.json())
        .then((body) => {
          if (!cancelled) setSeries(body)
        })
    }, 150_000)

    return () => {
      cancelled = true
      clearInterval(timer)
    }
  }, [key, days])

  // Re-base to the window's first point so each range starts at zero. The
  // series is absolute levels, so plotting them raw makes every range switch
  // look like a jump.
  const points = useMemo(() => {
    const candles = series?.candles ?? []
    const base = candles[0]?.c
    if (base === undefined || base === 0) return []
    return candles.map((bar) => ({
      t: bar.t * 1000,
      returnPct: (bar.c / base - 1) * 100,
      observed: bar.source === 'live',
    }))
  }, [series])

  return { points, resolutionMinutes: series?.resolutionMinutes ?? null }
}

import requests

BASE = "https://prices.indexes.fi"

marks = requests.get(f"{BASE}/v1/marks", timeout=10).json()

# The inputs every index price above was built from, so a quoted price can
# be checked rather than trusted.
for mark in marks:
    print(mark["feedSymbol"], mark["price"], mark["observedAt"])

const BASE = 'https://prices.indexes.fi'

const marks = await fetch(`${BASE}/v1/marks`).then((r) => r.json())

// The inputs every index price above was built from, so a quoted price can
// be checked rather than trusted.
for (const mark of marks) {
  console.log(mark.feedSymbol, mark.price, mark.observedAt)
}

import { useEffect, useState } from 'react'

const BASE = 'https://prices.indexes.fi'

export function ConstituentMarks() {
  const [marks, setMarks] = useState([])

  useEffect(() => {
    const read = () =>
      fetch(`${BASE}/v1/marks`, { cache: 'no-store' })
        .then((r) => r.json())
        .then(setMarks)

    void read()
    const timer = setInterval(read, 10_000)
    return () => clearInterval(timer)
  }, [])

  return (
    <table>
      <tbody>
        {marks.map((mark) => (
          <tr key={mark.feedSymbol}>
            <td>{mark.feedSymbol}</td>
            <td>{mark.price}</td>
            <td>{mark.observedAt}</td>
          </tr>
        ))}
      </tbody>
    </table>
  )
}

import json
import asyncio
import websockets   # pip install websockets

WS = "https://prices.indexes.fi".replace("https://", "wss://").replace("http://", "ws://")
KEY = "ixda-dtf-btc-eth-50-50"

async def main():
    # Reconnecting generator: the socket will drop, and a client that does
    # not reconnect goes quiet without reporting anything.
    async for socket in websockets.connect(f"{WS}/v1/stream?dtf={KEY}"):
        try:
            async for raw in socket:
                message = json.loads(raw)

                if message["type"] == "hello":
                    print("subscribed to", message["subscribed"])
                    continue

                if message["type"] == "tick":
                    stale = [l["symbol"] for l in message["legs"] if l["stale"]]
                    print(message["dtfId"], round(message["price"], 6), "stale:", stale)
        except websockets.ConnectionClosed:
            continue   # the generator reconnects with backoff

asyncio.run(main())

// Node 22 has a global WebSocket, so there is no dependency to add.
const WS = 'https://prices.indexes.fi'.replace(/^http/, 'ws')
const KEY = 'ixda-dtf-btc-eth-50-50'

const BACKOFF_MS = [500, 1_000, 2_000, 5_000, 10_000, 30_000]
let attempt = 0

function connect() {
  const socket = new WebSocket(`${WS}/v1/stream?dtf=${encodeURIComponent(KEY)}`)

  socket.onopen = () => {
    attempt = 0
  }

  socket.onmessage = (event) => {
    const message = JSON.parse(event.data)

    if (message.type === 'hello') {
      console.log('subscribed to', message.subscribed)
      return
    }

    if (message.type === 'tick') {
      const stale = message.legs.filter((leg) => leg.stale).map((leg) => leg.symbol)
      console.log(message.dtfId, message.price.toFixed(6), 'stale:', stale.join(', ') || 'none')
    }
  }

  // The socket will drop. A client that does not reconnect goes quiet
  // without reporting anything, which reads as a flat market.
  socket.onclose = () => {
    const delay = BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)]
    attempt += 1
    setTimeout(connect, delay)
  }
}

connect()

// Subscribe to more DTFs on the same socket at any time:
//   socket.send(JSON.stringify({ action: 'subscribe', dtf: ['IXDA', 'IXDB'] }))
//   socket.send(JSON.stringify({ action: 'unsubscribe', dtf: 'IXDB' }))

import { useEffect, useState } from 'react'

const BASE = 'https://prices.indexes.fi'
const BACKOFF_MS = [500, 1_000, 2_000, 5_000, 10_000, 30_000]

export function useDtfLivePrice(key) {
  const [tick, setTick] = useState(null)
  const [status, setStatus] = useState('connecting')

  useEffect(() => {
    let socket = null
    let retry = null
    let attempt = 0
    let closed = false

    const connect = () => {
      if (closed) return
      setStatus('connecting')
      socket = new WebSocket(
        `${BASE.replace(/^http/, 'ws')}/v1/stream?dtf=${encodeURIComponent(key)}`,
      )

      socket.onopen = () => {
        attempt = 0
        setStatus('live')
      }

      socket.onmessage = (event) => {
        const message = JSON.parse(event.data)
        if (message.type === 'tick') setTick(message)
      }

      socket.onclose = () => {
        socket = null
        if (closed) return
        setStatus('offline')
        const delay = BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)]
        attempt += 1
        retry = setTimeout(connect, delay)
      }
    }

    connect()

    return () => {
      closed = true
      if (retry !== null) clearTimeout(retry)
      if (socket !== null) {
        // Cleared first, or the handler reads this deliberate close as an
        // outage and reconnects a subscription nobody is listening to.
        socket.onclose = null
        socket.close()
      }
    }
  }, [key])

  const stale = (tick?.legs ?? []).some((leg) => leg.stale)

  return { tick, status, stale }
}

export function LivePrice({ dtfKey }) {
  const { tick, status, stale } = useDtfLivePrice(dtfKey)
  if (tick === null) return <span>awaiting price</span>

  return (
    <span data-live={status === 'live' && !stale}>
      {tick.price.toFixed(4)} USDC
      {stale ? ' (stale mark)' : ''}
    </span>
  )
}