How to Build a CS2 Buy Bot with Marketplace WebSockets and the Skinstrack API

npm install skinstrack ws centrifuge

import { SkinstracksV1 } from 'skinstrack';

const client = new SkinstracksV1({
  apiKey: process.env.SKINSTRACK_KEY,
});

// Sanity check: fetch one item end to end.
const ak = await client.getItem('AK-47 | Redline (Field-Tested)');
const cheapest = ak.prices.reduce((a, b) => (a.price < b.price ? a : b));
console.log(`cheapest ${cheapest.provider} @ $${cheapest.price}`);

import WebSocket from 'ws';

// Waxpeer Socket.IO endpoint. Auth is a request header at handshake time.
// Docs: https://docs.waxpeer.com (look for SocketIO / Examples).
const WAXPEER_WS = 'wss://waxpeer.com/socket.io/?EIO=4&transport=websocket';

const ws = new WebSocket(WAXPEER_WS, {
  headers: { authorization: process.env.WAXPEER_KEY },
});

ws.on('open', () => {
  // Subscribe to the public csgo stream. You will receive
  // "new", "update" and "removed" events per item.
  ws.send('42["subscribed",{"name":"csgo"}]');
  console.log('waxpeer connected');
});

ws.on('message', (raw) => {
  const text = raw.toString();
  if (!text.startsWith('42')) return;
  const [eventName, payload] = JSON.parse(text.slice(2));

  // Only react to new listings and price updates; ignore "removed".
  if (eventName !== 'new' && eventName !== 'update') return;
  if (!payload || payload.game !== 'csgo') return;

  // payload: { event, game, name, float, price, item_id, paint_index, ... }
  // Waxpeer prices are integers in 0.001 USD (e.g. 7260 -> $7.26).
  handleListing({
    source: 'waxpeer',
    name: payload.name,
    price: payload.price / 1000,
    listingId: String(payload.item_id),
    float: payload.float,
  });
});

import { Centrifuge } from 'centrifuge';
import WebSocket from 'ws';

// Market.CSGO uses Centrifugo. Flow:
//   1) GET /api/v2/get-ws-token?key=... -> short-lived token (valid ~10 min)
//   2) Connect to wss://wsprice.csgo.com/connection/websocket with that token
//   3) Subscribe to public:items:730:usd (730 = CS:GO/CS2 appid, currency USD)
// Docs: https://market.csgo.com (Web sockets section).

async function fetchToken() {
  const res = await fetch(
    `https://market.csgo.com/api/v2/get-ws-token?key=${process.env.MARKETCSGO_KEY}`
  );
  const data = await res.json();
  return data.token;
}

const centrifuge = new Centrifuge('wss://wsprice.csgo.com/connection/websocket', {
  websocket: WebSocket,
  // Auto-refresh the token; the server rejects it after ~10 minutes.
  getToken: fetchToken,
});

const sub = centrifuge.newSubscription('public:items:730:usd');

sub.on('publication', (ctx) => {
  // ctx.data is the published item event. The channel publishes both
  // new-listing and price-update payloads; field names follow market.csgo
  // conventions, so verify against your channel sample.
  const d = ctx.data ?? {};
  handleListing({
    source: 'market.csgo',
    name: d.i_market_hash_name ?? d.market_hash_name,
    price: parseFloat(d.price ?? d.ui_price),
    listingId: String(d.id ?? d.ui_id ?? ''),
  });
});

sub.subscribe();
centrifuge.connect();

// One getItems call covers the whole watchlist for 15 minutes.
// On each WebSocket event we read from memory, not from the API.

const CACHE_PROVIDERS = ['buff', 'youpin', 'csfloat'];
const CACHE_TTL_MS = 15 * 60 * 1000;

let priceCache = new Map(); // name -> { liquidity, prices }

async function refreshCache() {
  try {
    const items = await client.getItems({
      providers: CACHE_PROVIDERS.join(','),
    });
    const next = new Map();
    for (const item of items) {
      next.set(item.market_hash_name, {
        liquidity: item.liquidity ?? 0,
        prices: item.prices,
      });
    }
    priceCache = next;
    console.log(`cache refreshed: ${next.size} items`);
  } catch (err) {
    console.error('cache refresh failed', err);
  }
}

// Helper your WebSocket handlers will call.
function getCachedPrices(name) {
  return priceCache.get(name);
}

// Warm the cache, then refresh on a timer.
await refreshCache();
setInterval(refreshCache, CACHE_TTL_MS);

// Per-marketplace seller fees. Verify against current docs.
const SELLER_FEE = {
  steam: 0.13, buff: 0.025, csfloat: 0.02, youpin: 0.05,
  skinport: 0.12, waxpeer: 0.05, dmarket: 0.05, marketcsgo: 0.05,
};

// Minimum cross-market discount before we are interested.
const MIN_DISCOUNT = 0.12;
const MIN_LIQUIDITY = 50;

function shouldBuy(listing) {
  // Read from the 15 minute cache. No API call per event.
  const cached = getCachedPrices(listing.name);
  if (!cached || cached.liquidity < MIN_LIQUIDITY) return null;

  // Where could we sell this for the most, after fees?
  const candidates = cached.prices
    .filter((p) => p.provider !== listing.source)
    .map((p) => ({
      provider: p.provider,
      gross: p.price,
      fee: SELLER_FEE[p.provider] ?? 0.10,
      net: p.price * (1 - (SELLER_FEE[p.provider] ?? 0.10)),
    }));
  if (candidates.length === 0) return null;

  const best = candidates.reduce((a, b) => (a.net > b.net ? a : b));
  const profit = best.net - listing.price;
  const roi = profit / listing.price;
  if (roi < MIN_DISCOUNT) return null;

  return { listing, sellOn: best, profit, roi, liquidity: cached.liquidity };
}

// minimal-buy-bot.js  -  run: node minimal-buy-bot.js
import 'dotenv/config';
import WebSocket from 'ws';
import { Centrifuge } from 'centrifuge';
import { SkinstracksV1 } from 'skinstrack';

const client = new SkinstracksV1({ apiKey: process.env.SKINSTRACK_KEY });

const CACHE_PROVIDERS = ['buff', 'youpin', 'csfloat'];
const CACHE_TTL_MS = 15 * 60 * 1000;
const SELLER_FEE = {
  steam: 0.13, buff: 0.025, csfloat: 0.02, youpin: 0.05,
  skinport: 0.12, waxpeer: 0.05, dmarket: 0.05, marketcsgo: 0.05,
};
const MIN_DISCOUNT = 0.12;
const MIN_LIQUIDITY = 50;
const MAX_BUY_USD = 50;            // hard cap per buy

let priceCache = new Map();        // name -> { liquidity, prices }
const cooldown = new Map();        // de-dupe by item slug

async function refreshCache() {
  try {
    const items = await client.getItems({ providers: CACHE_PROVIDERS.join(',') });
    const next = new Map();
    for (const item of items) {
      next.set(item.market_hash_name, {
        liquidity: item.liquidity ?? 0,
        prices: item.prices,
      });
    }
    priceCache = next;
    console.log(`cache refreshed: ${next.size} items`);
  } catch (err) {
    console.error('cache refresh failed', err);
  }
}

function getCachedPrices(name) {
  return priceCache.get(name);
}

function evaluate(listing) {
  // Per-item cooldown so a flood of identical listings does not
  // re-fire the same decision a hundred times in 200ms.
  const last = cooldown.get(listing.name) ?? 0;
  if (Date.now() - last < 30_000) return;
  cooldown.set(listing.name, Date.now());

  if (listing.price > MAX_BUY_USD) return;

  // Read from the 15 minute cache. No API call per event.
  const cached = getCachedPrices(listing.name);
  if (!cached || cached.liquidity < MIN_LIQUIDITY) return;

  const candidates = cached.prices
    .filter((p) => p.provider !== listing.source)
    .map((p) => ({
      provider: p.provider,
      net: p.price * (1 - (SELLER_FEE[p.provider] ?? 0.10)),
    }));
  if (!candidates.length) return;

  const best = candidates.reduce((a, b) => (a.net > b.net ? a : b));
  const roi = (best.net - listing.price) / listing.price;
  if (roi < MIN_DISCOUNT) return;

  console.log(
    `[BUY] ${listing.source} @ $${listing.price} -> sell on ${best.provider}` +
    ` for ~$${best.net.toFixed(2)} net (${(roi * 100).toFixed(1)}%)`
  );
  // executeBuy(listing) is your marketplace-specific call;
  // each marketplace has its own buy endpoint and signing rules.
}

function connectWaxpeer() {
  const ws = new WebSocket(
    'wss://waxpeer.com/socket.io/?EIO=4&transport=websocket',
    { headers: { authorization: process.env.WAXPEER_KEY } }
  );
  ws.on('open', () => ws.send('42["subscribed",{"name":"csgo"}]'));
  ws.on('message', (raw) => {
    const t = raw.toString();
    if (!t.startsWith('42')) return;
    const [eventName, payload] = JSON.parse(t.slice(2));
    if (eventName !== 'new' && eventName !== 'update') return;
    if (!payload || payload.game !== 'csgo') return;
    evaluate({
      source: 'waxpeer',
      name: payload.name,
      price: payload.price / 1000,
      listingId: String(payload.item_id),
    });
  });
  ws.on('close', () => setTimeout(connectWaxpeer, 2000));
}

function connectMarketCsgo() {
  const centrifuge = new Centrifuge(
    'wss://wsprice.csgo.com/connection/websocket',
    {
      websocket: WebSocket,
      getToken: async () => {
        const res = await fetch(
          `https://market.csgo.com/api/v2/get-ws-token?key=${process.env.MARKETCSGO_KEY}`
        );
        const data = await res.json();
        return data.token;
      },
    }
  );

  const sub = centrifuge.newSubscription('public:items:730:usd');
  sub.on('publication', (ctx) => {
    const d = ctx.data ?? {};
    evaluate({
      source: 'marketcsgo',
      name: d.i_market_hash_name ?? d.market_hash_name,
      price: parseFloat(d.price ?? d.ui_price),
      listingId: String(d.id ?? d.ui_id ?? ''),
    });
  });

  sub.subscribe();
  centrifuge.connect();
}

// Warm the cache before listening to events.
await refreshCache();
setInterval(refreshCache, CACHE_TTL_MS);
connectWaxpeer();
connectMarketCsgo();