Streaming prices

Live prices come over a WebSocket, the same feed that moves the dashboard’s charts. One connection can follow as many tokens as you like, on Solana and EVM networks together.

The URL is wss://socket.neurotrading.io.

The price stream needs no token. You can connect from a script or straight from a browser.

Subscribing

Every message, in both directions, is a JSON object with a type. After connecting, send the token addresses you want to follow:


{ "type": "subscribe", "contractAddresses": ["Bp8m...pump", "0x6e2c...a41f"] }

The server confirms with the same list:


{ "type": "subscribed", "contractAddresses": ["Bp8m...pump", "0x6e2c...a41f"] }

From then on you receive a message every time one of those tokens trades. Stop following a token with:


{ "type": "unsubscribe", "contractAddresses": ["Bp8m...pump"] }

Subscriptions belong to the connection. If it drops, reconnect and subscribe again.

Send EVM addresses in lowercase. Addresses are matched exactly, and the feed publishes EVM tokens in lowercase, so a checksummed address (0x6E2C…A41F) subscribes successfully but never receives a tick. Solana addresses are case-sensitive — send them exactly as they are.

Solana ticks — `price_update`


{
  "type": "price_update",
  "data": {
    "contractAddress": "Bp8m...pump",
    "name": "Example",
    "symbol": "EXM",
    "priceNative": "0.0000000412",
    "priceInUsd": "0.00000736",
    "marketCapInSol": "41.2",
    "marketCapInUsd": "7360.11",
    "supply": "1000000000",
    "dexId": "pumpfun",
    "quoteMint": "So11111111111111111111111111111111111111112",
    "lastUpdatedAt": "2026-10-22T08:15:03.412Z"
  }
}

Field	Meaning
`priceNative`	Price of one token in SOL, whatever the pool is quoted in. A USDC pool’s price is converted to SOL.
`priceInUsd`	Price of one token in USD.
`marketCapInSol`, `marketCapInUsd`	Market cap in SOL and USD.
`dexId`	Where the swap happened (Pump.fun, PumpSwap, Raydium, …).
`quoteMint`	The token the pool is actually quoted in (SOL, USDC, USD1, …).
`lastUpdatedAt`	When the swap happened.

Numbers arrive as strings so no precision is lost — parse them with a decimal library if you do arithmetic on them.

Some price_update messages carry trading-activity figures instead of a fresh swap price. You can tell them apart because they include a metricsUpdatedAt field (a millisecond timestamp). If you only want prices, skip messages that have it.

EVM ticks — `evm_price_update`

Tokens on EVM networks, such as Robinhood Chain, arrive with their own message type on the same connection:


{
  "type": "evm_price_update",
  "data": {
    "chainId": 4663,
    "tokenAddress": "0x6e2c...a41f",
    "tokenSymbol": "EXM",
    "priceInQuote": "0.00000231",
    "quoteAsset": { "address": "0x...", "symbol": "ETH", "decimals": 18, "isNative": true },
    "source": "pons-curve",
    "venue": { "kind": "curve" },
    "graduationProgress": 0.42,
    "sellsClosed": false,
    "betweenVenues": false,
    "blockNumber": 1234567,
    "txHash": "0x...",
    "sourceEventId": "4663:0x...:7",
    "publishedAt": "2026-10-22T08:15:03.880Z"
  }
}

Field	Meaning
`priceInQuote`	Price of one whole token in whole units of `quoteAsset`. Not USD. A token can be priced in ETH, in USDG, or in a tokenised stock — always read `quoteAsset.symbol`.
`graduationProgress`	For a token still on its launch curve, how close it is to moving to a pool (0 to 1).
`sellsClosed`	`true` while the curve is full and about to graduate: buys still fill, sells fail. Do not send a sell while this is `true`.
`betweenVenues`	`true` for the moment between the curve closing and the pool opening. The price has not crashed — the token is moving.
`sourceEventId`	Unique per event. Use it to ignore a tick you have already seen.

Keeping the connection alive

The server sends a WebSocket ping every 30 seconds and closes connections that do not answer. Standard WebSocket clients (browsers, the Node ws package, Python websockets) answer pings automatically.

You can also check the connection yourself: send {"type": "ping"} and the server answers {"type": "pong"}. A message the server cannot read gets {"type": "error", "message": "..."} back, and the connection stays open.

Getting history

The stream only sends new trades. For candles — to seed an indicator, or to get a price for a token that has not traded since you subscribed — use the REST API (this one needs your session token):


curl -s "$NEURO_API/tokens/<tokenAddress>/ohlc?type=1m&from=1761120000&to=1761206400" \
  -H "Authorization: Bearer $NEURO_TOKEN"

Parameter	Notes
`type`	Candle size: `1s`, `30s`, `1m`, `5m`, `15m`, `30m`, `1h`, `4h`, `1d`. Default `1m`.
`from`, `to`	Unix time in seconds. Default: the last 24 hours.
`currency`	`usd` (default) or `native` — priced in the pool’s own quote token.
`quote_mint`	With `native`: which pool’s quote to chart, if the token trades in more than one.

Each candle in data.items has o, h, l, c (open, high, low, close), v and v_usd (volume), unix_time (the candle’s start, in seconds), and market-cap equivalents o_mc … c_mc where available.

Candle history is available for Solana tokens.

Example: follow a token in Node.js


// npm install ws
import WebSocket from "ws";
 
const TOKENS = ["Bp8m...pump"]; // EVM addresses: lowercase
 
function connect() {
  const ws = new WebSocket("wss://socket.neurotrading.io");
 
  ws.on("open", () => ws.send(JSON.stringify({ type: "subscribe", contractAddresses: TOKENS })));
 
  ws.on("message", (raw) => {
    const msg = JSON.parse(raw.toString());
    if (msg.type === "price_update" && msg.data.metricsUpdatedAt === undefined) {
      console.log(msg.data.symbol, "SOL", msg.data.priceNative, "USD", msg.data.priceInUsd);
    } else if (msg.type === "evm_price_update") {
      console.log(msg.data.tokenSymbol, msg.data.priceInQuote, msg.data.quoteAsset.symbol);
    } else if (msg.type === "error") {
      console.error("stream error:", msg.message);
    }
  });
 
  // Reconnect (and resubscribe) after a short pause whenever the connection drops.
  ws.on("close", () => setTimeout(connect, 2000));
  ws.on("error", () => ws.close());
}
 
connect();