Price Feed (Redis)

Overview

The AssetPay price feed is a low-latency firehose of item and price changes, delivered over Redis Streams at feed.assetpay.gg. Instead of polling the REST API, you tail a stream and react to each change as it happens - items entering the pool, items leaving, and price updates per marketplace. Each consumer reads a snapshot of current state once, then tails the stream for incremental changes. If you fall behind or reconnect, you re-read the snapshot and resume - no events are lost.

The Redis feed carries raw supplier prices and requires separately provisioned credentials. If you only need your own priced view of the market (the same items /secure/market?source=internal returns, with your fee applied), the WebSocket Market Updates event covers that with just your API key.

Connection

rediss://feed.assetpay.gg:6382 - TLS only; plaintext connections are rejected.

The feed is TLS-encrypted with a private CA. To connect you need:

The CA certificate (ca.crt) - AssetPay provides this; your client must trust it.
An ACL username + password - AssetPay issues these per integration.
SNI / servername set to feed.assetpay.gg when validating the certificate.

The feed is a raw Redis (TCP) endpoint, so feed.assetpay.gg resolves directly to the origin - it is not proxied like the HTTP API.

Access tiers

Your ACL user determines which keys you can read at all - anything outside your scope returns NOPERM.

ACL user	Sees	Use case
Per-market tenant (e.g. `waxpeer`, `ecosteam`)	That one market’s stream + snapshot only	A single-marketplace tenant - you never see another market’s prices
`market`	Every per-market stream (`autoseller:items:feed:*`)	An aggregator that wants each market separately
`partner`	The consolidated stream, all marketplaces in one block	A first-party consumer aggregating every market

Most integrations get a per-market user named after their market. Your username is your scope - the credentials AssetPay issues you already point at the right stream.

Streams & keys

Key	Type	Contents
`autoseller:items:feed`	Stream	Consolidated - every item with all marketplace prices
`autoseller:items:feed:snapshot`	Hash	Current state for the consolidated stream (`itemId` → block)
`autoseller:items:feed:<marketplace>`	Stream	Per-marketplace stream
`autoseller:items:feed:<marketplace>:snapshot`	Hash	Current state for that marketplace

Per-market streams exist for white_market, waxpeer, ecosteam, cs2dt and igxe. Only markets that are actually priced emit data - today white_market, waxpeer and ecosteam. cs2dt and igxe are reserved: their streams exist and stay empty until they get a price source, so a consumer can connect ahead of launch and simply receive nothing.

Event format

Each stream entry has two fields: type and data (a JSON string).

string

item.add, item.remove, or price.update.

JSON string

The event payload - see below.

`item.add`

A new item entered the pool (or its block was refreshed). On a per-market stream the payload is flattened to that market’s price:

{
  "id": "0f9c...",
  "appid": 730,
  "assetId": "39482...",
  "name": "AK-47 | Redline (Field-Tested)",
  "marketHashName": "AK-47 | Redline (Field-Tested)",
  "iconUrl": "https://...",
  "tradable": true,
  "delivery": "instant",
  "marketplace": "ecosteam",
  "price": "12.43",
  "updatedAt": "2026-06-15T12:00:00.000Z"
}

On the consolidated stream, prices are nested per marketplace. An item only carries the markets it is priced on, so the set of keys varies per item:

{
  "id": "0f9c...",
  "appid": 730,
  "name": "AK-47 | Redline (Field-Tested)",
  "prices": {
    "white_market": { "price": "12.43", "updatedAt": "2026-06-15T12:00:00.000Z" },
    "waxpeer": { "price": "12.44", "updatedAt": "2026-06-15T12:00:00.000Z" },
    "ecosteam": { "price": "12.41", "updatedAt": "2026-06-15T12:00:00.000Z" }
  }
}

Prices differ per market because each is quoted against that market’s own competitor book, under the same floor.

`price.update`

An existing item’s price changed on one marketplace:

{ "id": "0f9c...", "marketplace": "white_market", "price": "12.10", "updatedAt": "2026-06-15T12:05:00.000Z" }

`item.remove`

An item left the pool (sold or pulled):

{ "id": "0f9c..." }

Consuming the feed

Capture the stream position

Record the latest stream id (XREVRANGE <stream> + - COUNT 1) before seeding, so anything added during seeding replays from the stream - no gap.

Seed from the snapshot

HGETALL the snapshot hash to load current state in one round trip. Each field is an item id; each value is the JSON block.

Tail the stream

XREAD BLOCK 0 STREAMS <stream> <lastId> in a loop, applying each event and advancing lastId to each entry’s id.

Resync on disconnect

On reconnect, re-run from step 1. The snapshot is always current, so re-seeding reconciles any missed events.

Example (Node.js / ioredis)

import Redis from "ioredis";
import { readFileSync } from "node:fs";

// Your own market's stream - the one your ACL user is scoped to.
const STREAM = "autoseller:items:feed:ecosteam";

const r = new Redis("rediss://ecosteam:<YOUR_FEED_PASSWORD>@feed.assetpay.gg:6382", {
  tls: { ca: readFileSync("ca.crt"), servername: "feed.assetpay.gg" },
});

// 1. capture position  2. seed snapshot  3. tail
const top = await r.xrevrange(STREAM, "+", "-", "COUNT", 1);
let lastId = top[0]?.[0] ?? "0";

const snapshot = await r.hgetall(`${STREAM}:snapshot`);
for (const [, json] of Object.entries(snapshot)) {
  upsert(JSON.parse(json)); // your handler
}

while (true) {
  const res = await r.xread("COUNT", 200, "BLOCK", 0, "STREAMS", STREAM, lastId);
  for (const [, entries] of res ?? []) {
    for (const [id, fields] of entries) {
      lastId = id;
      const type = fields[fields.indexOf("type") + 1];
      const data = JSON.parse(fields[fields.indexOf("data") + 1]);
      handle(type, data); // item.add | item.remove | price.update
    }
  }
}

Use a dedicated client for the blocking XREAD ... BLOCK loop - it ties up the connection. Don’t reuse it for other commands.

Notes

Prices are decimal-dollar strings (e.g. "12.43"), not cents - parse carefully to avoid float rounding.
Streams are length-capped (~100k entries, trimmed automatically) - always seed from the snapshot rather than reading the stream from 0.
The snapshot is the source of truth. Membership is reconciled against it continuously, so an item present there is live even if you missed its item.add.
Credentials and the CA are issued per integration - contact AssetPay to provision feed access.

Getting Started

Integration

Events & Webhooks

Reference

Price Feed (Redis)

Overview

Connection

Access tiers

Streams & keys

Event format

`item.add`

`price.update`

`item.remove`

Consuming the feed

Example (Node.js / ioredis)

Notes

​Overview

​Connection

​Access tiers

​Streams & keys

​Event format

​item.add

​price.update

​item.remove

​Consuming the feed

​Example (Node.js / ioredis)

​Notes

Overview

Connection

Access tiers

Streams & keys

Event format

`item.add`

`price.update`

`item.remove`

Consuming the feed

Example (Node.js / ioredis)

Notes