Introduction

16:24:45  Bayern (Shelby) vs Hoffenheim (Professor) · Esoccer GT Leagues - 12 mins play · 20 Oct 16:15  1x2  1.42 / 3.60 / 5.50
16:24:51  Spain (GUARDIAN) vs France (DEZZY) · Esoccer H2H GG League - 8 mins play · 20 Oct 16:23  BET STOP  3 lines
16:26:47  Newcastle (MJ) vs Arsenal (SPARTAN) · Esoccer H2H GG League - 8 mins play · 20 Oct 16:12  SETTLED  Total 2.5  won: over 2.5

python -m venv .venv && . .venv/bin/activate
pip install -r requirements.txt
FEED_API_KEY=your-key python app.py

httpx==0.28.1
httpx-sse==0.4.3

"""Minimal odds app: one printed line per price change, bet stop and settlement."""
import json, os, re, time
from datetime import datetime
import httpx
from httpx_sse import connect_sse

key = os.environ['FEED_API_KEY']  # Keep the key on your server.
base = os.environ.get('FEED_API_URL', 'https://dev.feed.sportlive.hr')
headers = {'X-API-Key': key}
client = httpx.Client(timeout=30)  # alive arrives every 10 s; 30 s of silence reconnects.
titles, markets, book, staged = {}, {}, {}, None

def remember(fixture, tournament):  # "Home vs Away · Tournament · kickoff"
    kickoff = datetime.fromisoformat(fixture['scheduledTime']).astimezone()
    titles[fixture['urn']] = f"{fixture['name']} · {tournament} · {kickoff:%d %b %H:%M}"

def show(urn, text):
    if urn not in titles:  # A fixture that is new since start-up: look it up once.
        response = client.get(base + '/tenant-catalog-api/fixtures/' + urn, headers=headers)
        remember(response.json(), 'eSoccer') if response.is_success else None
    print(f"{datetime.now():%H:%M:%S}  {titles.get(urn, 'New fixture')}  {text}", flush=True)

def name(text, market, urn):  # Fill {total}, {hcp}, {$competitor1} from the line and teams.
    home, _, away = titles.get(urn, '').split(' · ')[0].partition(' vs ')
    values = {**market.get('specifiers', {}), '$competitor1': home, '$competitor2': away}
    return re.sub(r'\{[+-]?([$\w]+)\}', lambda m: values.get(m[1], m[0]), text)

def label(market, urn):  # "Total 2.5": the market's name in the descriptions, then its line.
    found = markets.get(market['marketId'], {'name': f"Market {market['marketId']}"})
    return ' '.join([name(found['name'], market, urn), *market.get('specifiers', {}).values()])

def merge(target, urn, changed):  # Book: fixture -> line -> status and outcome prices.
    for market in changed:
        line = target.setdefault(urn, {}).setdefault((market['marketId'], market['line']), {})
        line.update({o['outcomeId']: o['odds'] if o['active'] else None
                     for o in market.get('outcomes', [])}, status=market['status'])
        prices = ' / '.join('%.2f' % v if v else '-' for k, v in line.items() if k != 'status')
        yield label(market, urn) + '  ' + (prices if market['status'] == 'active' else 'suspended')

def apply(event, data):
    global staged
    urn, lines = data.get('fixtureUrn'), book.get(data.get('fixtureUrn'), {})
    if event == 'snapshot_start':  # A full replacement: keep the old book until it completes.
        staged = {}
    elif event == 'fixture_snapshot':
        (book if staged is None else staged).pop(urn, None)
        list(merge(book if staged is None else staged, urn, data['fixture']['markets']))
    elif event == 'snapshot_complete' and staged is not None:
        book.clear(), book.update(staged)
        staged = None
    elif event == 'odds_change':
        for text in merge(book, urn, data['markets']):
            show(urn, text)
    elif event == 'bet_stop':
        stopped = {(m['marketId'], m['line']) for m in data.get('markets', [])}
        for ref in lines if data['scope'] == 'fixture' else stopped & lines.keys():
            lines[ref]['status'] = 'suspended'
        show(urn, 'BET STOP  ' + (f'{len(stopped)} lines' if stopped else 'all markets'))
    elif event == 'bet_settlement':
        for market in data['markets']:
            lines.pop((market['marketId'], market['line']), None)
            outcomes = markets.get(market['marketId'], {}).get('outcomes', [])
            names = {o['id']: o['name'] for o in outcomes}
            won = [name(names.get(o['outcomeId'], o['outcomeId']), market, urn)
                   for o in market['outcomes'] if o['result'] == 'won']
            show(urn, f"SETTLED  {label(market, urn)}  won: {', '.join(won) or '-'}")
    elif event == 'fixture_removed':
        book.pop(urn, None)

response = client.get(base + '/tenant-catalog-api/descriptions/markets')  # No key needed.
markets.update({m['id']: m for m in response.json()} if response.is_success else {})
response = client.get(base + '/tenant-catalog-api/tournaments', headers=headers)
response.raise_for_status()
for tournament in response.json():  # Load fixture names once, tournament by tournament.
    detail = client.get(base + '/tenant-catalog-api/tournaments/' + tournament['urn'],
                        headers=headers)
    for fixture in detail.json()['fixtures'] if detail.is_success else []:
        remember(fixture, tournament['name'])
delay = 1
while True:  # Each connection: a fresh snapshot, then the stream from its cut.
    try:
        response = client.get(base + '/tenant-odds-output/odds/fixtures', headers=headers)
        response.raise_for_status()
        book.clear()
        for fixture in response.json()['fixtures']:
            list(merge(book, fixture['fixtureUrn'], fixture['markets']))
        print('book:', len(book), 'fixtures', flush=True)
        cursor, staged = response.json()['cut'], None
        with connect_sse(client, 'GET', base + '/tenant-odds-output/odds/events',
                         headers={**headers, 'Last-Event-ID': cursor}) as source:
            source.response.raise_for_status()
            for message in source.iter_sse():
                apply(message.event, json.loads(message.data))
                delay = 1
    except httpx.HTTPStatusError as error:
        if error.response.status_code in (401, 402, 403):
            raise  # Restore access first: see Errors and limits.
        delay = int(error.response.headers.get('Retry-After', delay))
    except httpx.TransportError:
        pass  # A network failure, or 30 s without data.
    print('reconnecting in', delay, 's', flush=True)
    time.sleep(delay)
    delay = min(delay * 2, 60)

API reference: GET /tenant-catalog-api/descriptions/markets GET /tenant-catalog-api/tournaments GET /tenant-odds-output/odds/fixtures GET /tenant-odds-output/odds/events

npm install
FEED_API_KEY=your-key node app.mjs

{
  "private": true,
  "type": "module",
  "engines": { "node": ">=22" },
  "dependencies": { "eventsource": "5.1.2" }
}

// Minimal odds app: one printed line per price change, bet stop and settlement.
import { EventSource } from 'eventsource';
const API_KEY = process.env.FEED_API_KEY;  // Keep the key on your server.
const BASE = process.env.FEED_API_URL ?? 'https://dev.feed.sportlive.hr';
const headers = { 'X-API-Key': API_KEY };
const titles = new Map(), markets = new Map();
let book = new Map(), staged = null, delay = 1;

const remember = (fixture, tournament) => titles.set(fixture.urn, [fixture.name, tournament,
  new Date(fixture.scheduledTime).toLocaleString([], { dateStyle: 'medium', timeStyle: 'short' }),
].join(' · '));  // "Home vs Away · Tournament · kickoff"
async function show(urn, text) {
  if (!titles.has(urn)) {  // A fixture that is new since start-up: look it up once.
    const response = await fetch(BASE + '/tenant-catalog-api/fixtures/' + urn, { headers });
    if (response.ok) remember(await response.json(), 'eSoccer');
  }
  console.log(new Date().toLocaleTimeString(), '', titles.get(urn) ?? 'New fixture', '', text);
}
function fill(text, market, urn) {  // {total}, {hcp}, {$competitor1} from the line and teams.
  const [home, away] = (titles.get(urn) ?? '').split(' · ')[0].split(' vs ');
  const values = { ...market.specifiers, $competitor1: home, $competitor2: away };
  return text.replace(/\{[+-]?([$\w]+)\}/g, (all, name) => values[name] ?? all);
}
const label = (market, urn) => [fill(markets.get(market.marketId)?.name ??
  `Market ${market.marketId}`, market, urn), ...Object.values(market.specifiers ?? {})].join(' ');
const ref = (market) => `${market.marketId}|${market.line}`;

function* merge(target, urn, changed) {  // Book: fixture -> line -> status and outcome prices.
  if (!target.has(urn)) target.set(urn, new Map());
  for (const market of changed) {
    const line = target.get(urn).get(ref(market)) ?? { odds: {} };
    line.status = market.status;
    for (const o of market.outcomes ?? []) line.odds[o.outcomeId] = o.active ? o.odds : null;
    target.get(urn).set(ref(market), line);
    const prices = Object.values(line.odds).map((v) => (v ? v.toFixed(2) : '-')).join(' / ');
    yield `${label(market, urn)}  ${market.status === 'active' ? prices : 'suspended'}`;
  }
}
async function apply(event, data) {
  const urn = data.fixtureUrn, lines = book.get(urn) ?? new Map();
  if (event === 'snapshot_start') staged = new Map();  // Keep the old book until complete.
  if (event === 'fixture_snapshot') {
    (staged ?? book).delete(urn);
    [...merge(staged ?? book, urn, data.fixture.markets)];
  }
  if (event === 'snapshot_complete' && staged) [book, staged] = [staged, null];
  if (event === 'odds_change') for (const text of merge(book, urn, data.markets)) {
    await show(urn, text);
  }
  if (event === 'bet_stop') {
    const stopped = new Set((data.markets ?? []).map(ref));
    for (const [key, line] of lines) {
      if (data.scope === 'fixture' || stopped.has(key)) line.status = 'suspended';
    }
    await show(urn, `BET STOP  ${stopped.size ? `${stopped.size} lines` : 'all markets'}`);
  }
  if (event === 'bet_settlement') for (const market of data.markets) {
    lines.delete(ref(market));
    const outcomes = markets.get(market.marketId)?.outcomes ?? [];
    const names = new Map(outcomes.map((o) => [o.id, o.name]));
    const won = market.outcomes.filter((o) => o.result === 'won')
      .map((o) => fill(names.get(o.outcomeId) ?? o.outcomeId, market, urn));
    await show(urn, `SETTLED  ${label(market, urn)}  won: ${won.join(', ') || '-'}`);
  }
  if (event === 'fixture_removed') book.delete(urn);
}
const names = ['snapshot_start', 'fixture_snapshot', 'snapshot_complete', 'odds_change',
  'bet_stop', 'bet_settlement', 'fixture_removed', 'alive'];

function later(why, seconds = delay) {  // Rebuild from a new snapshot after a backoff.
  console.log(`reconnecting in ${seconds} s (${why})`);
  setTimeout(() => connect().catch(failed), seconds * 1000);
  delay = Math.min(delay * 2, 60);
}
function failed(error) {
  if ([401, 402, 403].includes(error.status)) throw error;  // Restore access first.
  later(error.message, error.retryAfter ?? delay);
}
async function connect() {  // Each connection: a fresh snapshot, then the stream from its cut.
  const response = await fetch(BASE + '/tenant-odds-output/odds/fixtures', { headers });
  if (!response.ok) {
    throw Object.assign(new Error(`HTTP ${response.status}`), { status: response.status,
      retryAfter: Number(response.headers.get('Retry-After')) || undefined });
  }
  const snapshot = await response.json();
  book = new Map(), staged = null;
  for (const fixture of snapshot.fixtures) [...merge(book, fixture.fixtureUrn, fixture.markets)];
  console.log('book:', book.size, 'fixtures');
  const lastAppliedId = snapshot.cut;
  const source = new EventSource(BASE + '/tenant-odds-output/odds/events', {
    fetch: (url, init) => fetch(url, {
      ...init,
      headers: { ...init.headers, ...headers, 'Last-Event-ID': lastAppliedId },
    }),
  });
  let queue = Promise.resolve(), watchdog;
  const stop = (why) => {
    if (source.readyState === EventSource.CLOSED) return;
    source.close(), clearTimeout(watchdog), later(why);
  };
  const arm = () => {  // alive arrives every 10 s; 30 s of silence reconnects.
    clearTimeout(watchdog), watchdog = setTimeout(() => stop('no data for 30 s'), 30000);
  };
  for (const name of names) source.addEventListener(name, (message) => {
    arm(), delay = 1;
    queue = queue.then(() => apply(name, JSON.parse(message.data)));
  });
  source.addEventListener('error', (error) => stop(error.message ?? 'network'));
  arm();
}

const descriptions = await fetch(BASE + '/tenant-catalog-api/descriptions/markets');  // No key.
if (descriptions.ok) for (const market of await descriptions.json()) markets.set(market.id, market);
const list = await fetch(BASE + '/tenant-catalog-api/tournaments', { headers });
if (!list.ok) throw new Error(`HTTP ${list.status}`);
for (const tournament of await list.json()) {  // Load fixture names once, per tournament.
  const detail = await fetch(
    BASE + '/tenant-catalog-api/tournaments/' + tournament.urn, { headers });
  if (detail.ok) for (const f of (await detail.json()).fixtures) remember(f, tournament.name);
}
await connect().catch(failed);

API reference: GET /tenant-odds-output/odds/fixtures GET /tenant-odds-output/odds/events GET /tenant-catalog-api/descriptions/markets GET /tenant-catalog-api/tournaments

curl "$BASE/tenant-catalog-api/sports" \
  -H "X-API-Key: $API_KEY"
curl "$BASE/tenant-catalog-api/tournaments" \
  -H "X-API-Key: $API_KEY"
curl "$BASE/tenant-catalog-api/fixtures/$FIXTURE?locale=en" \
  -H "X-API-Key: $API_KEY"

API reference: GET /tenant-catalog-api/sports GET /tenant-catalog-api/tournaments GET /tenant-catalog-api/fixtures/{urn}

{
  "urn": "sportlive:match:42",
  "sportUrn": "sportlive:sport:2",
  "categoryUrn": "sportlive:category:4",
  "tournamentUrn": "sportlive:tournament:17",
  "name": "Team A v Team B",
  "scheduledTime": "2026-10-14T12:00:00Z",
  "liveOdds": 1
}

curl "$BASE/tenant-odds-output/odds/fixtures" \
  -H "X-API-Key: $API_KEY"

API reference: GET /tenant-odds-output/odds/fixtures

curl "$BASE/tenant-odds-output/odds/status" \
  -H "X-API-Key: $API_KEY"

API reference: GET /tenant-odds-output/odds/status

import json, os, time
import httpx
from httpx_sse import connect_sse
from your_app import replace_book, apply_event
base, key = os.environ['BASE'], os.environ['API_KEY']
headers = {'X-API-Key': key}
names = (
    'snapshot_start', 'fixture_snapshot', 'snapshot_complete', 'odds_change',
    'bet_stop', 'fixture_change', 'fixture_removed', 'alive', 'bet_settlement',
    'bet_cancel', 'rollback_bet_settlement', 'rollback_bet_cancel',
)
handlers = {name: lambda data, name=name: apply_event(name, data) for name in names}
with httpx.Client(timeout=30) as client:
    response = client.get(base + '/tenant-odds-output/odds/fixtures', headers=headers)
    response.raise_for_status()
    snapshot = response.json()
    replace_book(snapshot['fixtures'])
    cursor = snapshot['cut']
    while True:
        try:
            with connect_sse(
                client, 'GET', base + '/tenant-odds-output/odds/events',
                headers={**headers, 'Last-Event-ID': cursor},
            ) as source:
                source.response.raise_for_status()
                for message in source.iter_sse():
                    handlers[message.event](json.loads(message.data))
                    if message.event == 'snapshot_start' or message.id:
                        cursor = message.id
        except httpx.HTTPStatusError:
            raise  # Handle access and Retry-After before retrying.
        except httpx.TransportError:
            pass
        time.sleep(2)

API reference: GET /tenant-odds-output/odds/fixtures GET /tenant-odds-output/odds/events

import { EventSource } from 'eventsource';
import { replaceBook, applyEvent } from './your-app.js';
const { BASE, API_KEY } = process.env;
const headers = { 'X-API-Key': API_KEY };
const response = await fetch(BASE + '/tenant-odds-output/odds/fixtures', { headers });
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const snapshot = await response.json();
replaceBook(snapshot.fixtures);
let lastAppliedId = snapshot.cut;
const source = new EventSource(BASE + '/tenant-odds-output/odds/events', {
  fetch: (url, init) => fetch(url, {
    ...init,
    headers: { ...init.headers, ...headers, 'Last-Event-ID': lastAppliedId },
  }),
});
const names = [
  'snapshot_start', 'fixture_snapshot', 'snapshot_complete', 'odds_change',
  'bet_stop', 'fixture_change', 'fixture_removed', 'alive', 'bet_settlement',
  'bet_cancel', 'rollback_bet_settlement', 'rollback_bet_cancel',
];
for (const name of names) {
  source.addEventListener(name, message => {
    try {
      applyEvent(name, JSON.parse(message.data));
      if (name === 'snapshot_start' || message.lastEventId) {
        lastAppliedId = message.lastEventId;
      }
    } catch (error) {
      source.close();  // Stop before an unapplied event can be skipped.
      throw error;
    }
  });
}
source.addEventListener('error', error => {
  if (error.code === 401 || error.code === 402 || error.code === 403) {
    source.close();  // Restore access before creating a new connection.
  }
  // Network failures reconnect automatically through the custom fetch above.
});

API reference: GET /tenant-odds-output/odds/fixtures GET /tenant-odds-output/odds/events

import os
import niquests
base, key = os.environ['BASE'], os.environ['API_KEY']
sse_base = 'sse://' + base.removeprefix('https://')
headers = {'X-API-Key': key}
with niquests.Session() as session:
    # The first answer carries Alt-Svc; later connections to this origin use HTTP/3.
    response = session.get(base + '/tenant-odds-output/odds/fixtures', headers=headers)
    response.raise_for_status()
    cursor = response.json()['cut']
    stream = session.get(
        sse_base + '/tenant-odds-output/odds/events',
        headers={**headers, 'Last-Event-ID': cursor},
    )
    stream.raise_for_status()
    print('protocol', stream.http_version)  # 30 = HTTP/3, 20 = HTTP/2
    while not stream.extension.closed:
        message = stream.extension.next_payload()
        if message is None:
            continue
        print(message.event, message.id, len(message.data))

API reference: GET /tenant-odds-output/odds/fixtures GET /tenant-odds-output/odds/events

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.regex.Pattern;

public class StreamH3 {
    public static void main(String[] args) throws Exception {
        String base = System.getenv("BASE"), key = System.getenv("API_KEY");
        // JDK 26+: prefer HTTP/3; the client falls back to HTTP/2 or HTTP/1.1.
        HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_3).build();
        HttpRequest snapshot = HttpRequest.newBuilder(
                URI.create(base + "/tenant-odds-output/odds/fixtures"))
            .header("X-API-Key", key).build();
        String body = client.send(snapshot, HttpResponse.BodyHandlers.ofString()).body();
        var cut = Pattern.compile("\"cut\"\\s*:\\s*\"([^\"]*)\"").matcher(body);
        String cursor = cut.find() ? cut.group(1) : "";  // Use your JSON library here.
        HttpRequest events = HttpRequest.newBuilder(
                URI.create(base + "/tenant-odds-output/odds/events"))
            .header("X-API-Key", key).header("Last-Event-ID", cursor).build();
        var stream = client.send(events, HttpResponse.BodyHandlers.ofLines());
        System.out.println("protocol " + stream.version());  // HTTP_3 or HTTP_2
        String event = "", lastId = "";
        StringBuilder data = new StringBuilder();
        for (String line : (Iterable<String>) stream.body()::iterator) {
            if (line.isEmpty()) {  // A blank line ends one event.
                if (!event.isEmpty()) System.out.println(event + " " + lastId + " " + data);
                event = "";
                data.setLength(0);
            } else if (line.startsWith("event:")) event = line.substring(6).strip();
            else if (line.startsWith("id:")) lastId = line.substring(3).strip();
            else if (line.startsWith("data:")) data.append(line.substring(5).strip());
        }
    }
}

API reference: GET /tenant-odds-output/odds/fixtures GET /tenant-odds-output/odds/events

using System.Net;
using System.Net.ServerSentEvents;
using System.Text.Json;

var baseUrl = Environment.GetEnvironmentVariable("BASE");
var key = Environment.GetEnvironmentVariable("API_KEY");
// .NET 7+: ask for HTTP/3 and accept HTTP/2 or HTTP/1.1 when QUIC is not available.
using var client = new HttpClient
{
    DefaultRequestVersion = HttpVersion.Version30,
    DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrLower,
    Timeout = Timeout.InfiniteTimeSpan,
};
using var snapshot = new HttpRequestMessage(HttpMethod.Get,
    baseUrl + "/tenant-odds-output/odds/fixtures");
snapshot.Headers.Add("X-API-Key", key);
using var book = await client.SendAsync(snapshot);
book.EnsureSuccessStatusCode();
using var json = JsonDocument.Parse(await book.Content.ReadAsStringAsync());
var cursor = json.RootElement.GetProperty("cut").GetString();
using var events = new HttpRequestMessage(HttpMethod.Get,
    baseUrl + "/tenant-odds-output/odds/events");
events.Headers.Add("X-API-Key", key);
events.Headers.Add("Last-Event-ID", cursor);
using var response = await client.SendAsync(events, HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();
Console.WriteLine($"protocol {response.Version}");  // 3.0 = HTTP/3, 2.0 = HTTP/2
await using var body = await response.Content.ReadAsStreamAsync();
await foreach (var item in SseParser.Create(body).EnumerateAsync())
{
    Console.WriteLine($"{item.EventType} {item.EventId} {item.Data.Length}");
}

API reference: GET /tenant-odds-output/odds/fixtures GET /tenant-odds-output/odds/events

curl "$BASE/tenant-odds-output/odds/accounting?since=$SINCE&limit=500" \
  -H "X-API-Key: $API_KEY"
curl "$BASE/tenant-odds-output/odds/accounting?after=$NEXT&limit=500" \
  -H "X-API-Key: $API_KEY"
curl "$BASE/tenant-odds-output/odds/accounting/fixtures?fixture=$FIXTURE&since=$SINCE" \
  -H "X-API-Key: $API_KEY"

API reference: GET /tenant-odds-output/odds/accounting GET /tenant-odds-output/odds/accounting/fixtures

{
  "reason": "connect",
  "sentAt": 1800000000000
}

{
  "fixture": {
    "fixtureUrn": "sportlive:match:9001",
    "markets": [
      {
        "extendedSpecifiers": {
          "score": "0:0"
        },
        "line": "hcp=-0.5|total=2.5",
        "marketId": 1,
        "outcomes": [
          {
            "active": true,
            "odds": 1.85,
            "outcomeId": "1"
          }
        ],
        "specifiers": {
          "hcp": "-0.5",
          "total": "2.5"
        },
        "status": "active"
      }
    ],
    "matchStatus": {
      "awayScore": 0,
      "homeScore": 0,
      "status": "live"
    },
    "sportUrn": "sportlive:sport:2",
    "updatedAt": 1800000000000
  },
  "fixtureUrn": "sportlive:match:9001",
  "reason": "snapshot",
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2"
}

{
  "fixtures": 1,
  "sentAt": 1800000000000
}

{
  "fixtureUrn": "sportlive:match:9001",
  "markets": [
    {
      "extendedSpecifiers": {
        "score": "0:0"
      },
      "line": "hcp=-0.5|total=2.5",
      "marketId": 1,
      "outcomes": [
        {
          "active": true,
          "odds": 1.85,
          "outcomeId": "1"
        }
      ],
      "specifiers": {
        "hcp": "-0.5",
        "total": "2.5"
      },
      "status": "active"
    }
  ],
  "matchStatus": {
    "awayScore": 0,
    "homeScore": 0,
    "status": "live"
  },
  "producedAt": 1800000000000,
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2"
}

{
  "fixtureUrn": "sportlive:match:9001",
  "markets": [
    {
      "extendedSpecifiers": {
        "score": "0:0"
      },
      "line": "hcp=-0.5|total=2.5",
      "marketId": 1,
      "specifiers": {
        "hcp": "-0.5",
        "total": "2.5"
      }
    }
  ],
  "producedAt": 1800000000000,
  "reason": 900,
  "scope": "markets",
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2",
  "status": "suspended"
}

{
  "changeType": "status",
  "fixtureUrn": "sportlive:match:9001",
  "lastModified": 1800000000000,
  "producedAt": 1800000000000,
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2"
}

{
  "fixtureUrn": "sportlive:match:9001",
  "producedAt": 1800000000000,
  "reason": "ended",
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2"
}

{
  "feeds": [
    {
      "feed": "live",
      "status": "up"
    },
    {
      "feed": "prematch",
      "status": "up"
    }
  ],
  "sentAt": 1800000000000
}

{
  "accountingId": "0123456789abcdef0123456789abcdef",
  "certainty": 1,
  "fixtureUrn": "sportlive:match:9001",
  "markets": [
    {
      "extendedSpecifiers": {
        "score": "0:0"
      },
      "line": "hcp=-0.5|total=2.5",
      "marketId": 1,
      "outcomes": [
        {
          "deadHeatFactor": 0.5,
          "outcomeId": "1",
          "result": "won",
          "voidFactor": 0.5
        }
      ],
      "specifiers": {
        "hcp": "-0.5",
        "total": "2.5"
      }
    }
  ],
  "producedAt": 1800000000000,
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2"
}

{
  "accountingId": "0123456789abcdef0123456789abcde1",
  "fixtureUrn": "sportlive:match:9001",
  "from": 1799999995000,
  "markets": [
    {
      "extendedSpecifiers": {
        "score": "0:0"
      },
      "line": "hcp=-0.5|total=2.5",
      "marketId": 1,
      "outcomeIds": [
        "1"
      ],
      "specifiers": {
        "hcp": "-0.5",
        "total": "2.5"
      }
    }
  ],
  "producedAt": 1800000000000,
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2",
  "to": 1800000000000
}

{
  "accountingId": "0123456789abcdef0123456789abcde2",
  "fixtureUrn": "sportlive:match:9001",
  "markets": [
    {
      "extendedSpecifiers": {
        "score": "0:0"
      },
      "line": "hcp=-0.5|total=2.5",
      "marketId": 1,
      "specifiers": {
        "hcp": "-0.5",
        "total": "2.5"
      }
    }
  ],
  "producedAt": 1800000000000,
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2"
}

{
  "accountingId": "0123456789abcdef0123456789abcde3",
  "fixtureUrn": "sportlive:match:9001",
  "markets": [
    {
      "extendedSpecifiers": {
        "score": "0:0"
      },
      "line": "hcp=-0.5|total=2.5",
      "marketId": 1,
      "specifiers": {
        "hcp": "-0.5",
        "total": "2.5"
      }
    }
  ],
  "producedAt": 1800000000000,
  "sentAt": 1800000000000,
  "sportUrn": "sportlive:sport:2"
}