If you run an automated trading system, you already know the input is the hard part. The moment Binance, Upbit, or Bithumb publishes a new-listing notice, the clock starts. Every other bot pointed at the same event is racing, and the gap between "first to act" and "fifth to act" is the entire edge.
A piece of context that surprises people new to this: the announcement and the actual listing are usually days apart. Binance posts "we will list TOKEN on futures" and the contract goes live later. The trade traders most want isn't on the announcing exchange at all — it's usually on a different venue (a derivatives or spot market) where the token already trades or lists shortly after, capturing the move as the news propagates. So the thing you're actually optimizing is detection-to-signal latency of the notice, not order execution on the publisher.
I spent a while wiring up five different ingestion methods into the same bot skeleton and comparing them across the criteria that actually matter in production. Here's what I found, with code.
The criteria
I'm not going to score these on "vibes." Here's the matrix I evaluated against, because for a trading bot the slowest-but-most-reliable method can still beat the fastest-but-flaky one over a month of real listings:
| Criterion | Why it matters |
|---|---|
| Latency | Detection-to-signal time. The whole game. |
| Coverage | Does it catch spot listings, futures listings, delistings, airdrops, caution/monitoring tags — across Binance and the Korean exchanges? |
| Reliability | Does it fire on every event, or silently miss some? False negatives are invisible until you audit. |
| Structured output | Do you get a clean ticker/type/exchange you can route on, or a blob of HTML/text you have to parse? |
| Cost | Money + rate-limit budget. |
| Maintenance | How often does it break when an exchange changes a page or a bot account gets rate-limited? |
Let me go method by method.
Method 1: REST polling the exchange announcement endpoints
The obvious first instinct: just hit the exchange's "announcements" page/endpoint on a loop and diff the result.
import httpx, asyncio, time SEEN: set[str] = set() URL = "https://EXCHANGE/announcements-endpoint" async def poll(): async with httpx.AsyncClient(timeout=5) as client: while True: t0 = time.perf_counter() try: r = await client.get(URL, params={"type": 1, "pageSize": 20}) for art in r.json()["data"]["catalogs"][0]["articles"]: aid = str(art["id"]) if aid not in SEEN: SEEN.add(aid) handle_new(art["title"], art["code"]) except Exception as e: print("poll error", e) # respect rate limits await asyncio.sleep(max(0.0, 2.0 - (time.perf_counter() - t0))) The honest pros: it's free, it's yours, no third party in the path, and you can run it from anywhere. For a single exchange it's maybe 40 lines.
The honest cons: your latency is bounded by your poll interval. Poll on a loop and your average detection delay is half your interval — before you've even parsed anything. Tighten the loop and you start eating rate limits or soft-bans. Then multiply the whole thing: Upbit and Bithumb have completely different endpoints, different pagination, different payload shapes, Korean-language titles, and their own rate-limit personalities. You're now maintaining three brittle scrapers, and every one of them breaks the day an exchange tweaks a JSON field. Coverage of the interesting event types (caution releases, monitoring-tag changes, airdrops) means parsing titles in two languages.
| Score | |
|---|---|
| Latency | Poor (bounded by poll interval) |
| Coverage | Medium (you build each exchange yourself) |
| Reliability | Medium (rate-limit bans, silent endpoint changes) |
| Structured output | Poor (you parse everything) |
| Cost | Free in $, expensive in your time |
| Maintenance | High |
Good for a hobby project on one exchange. Painful as a production multi-exchange edge.
Method 2: A Telegram listing bot as your source
There are popular Telegram channels/bots that broadcast listing announcements. The clever trick is you don't have to read them as a human — you can have your bot join the channel and consume messages programmatically with Telethon or the Bot API.
from telethon import TelegramClient, events client = TelegramClient("session", api_id, api_hash) @client.on(events.NewMessage(chats=["some_listing_channel"])) async def on_msg(event): text = event.raw_text ticker = extract_ticker(text) # you still parse free-form text if ticker and "list" in text.lower(): route_order(ticker) client.start() client.run_until_disconnected() The honest pros: zero infrastructure on your side, often free, and a good Telegram source has already done the cross-exchange aggregation and language handling for you. For a lot of manual traders this is genuinely the right tool, and as a machine input it's better than nothing.
The honest cons: you inherit two delays you don't control — the channel's own detection lag, plus Telegram's delivery. Public competitor ranges put Telegram listing bots somewhere around 150–500 ms end to end, and you can't tune it because it's not your pipeline. You're also consuming free-form human-readable text, so you're back to regex-parsing tickers out of prose ("will be listed", "상장", "上场"…), and a wording change silently breaks your extractor. Reliability depends on a third party's uptime and on your account not getting rate-limited or kicked. It's an opaque box: when it misses an event, you find out the hard way.
| Score | |
|---|---|
| Latency | Medium (~150–500 ms, not tunable) |
| Coverage | Medium–Good (depends on the channel) |
| Reliability | Medium (third-party uptime, account limits) |
| Structured output | Poor (parse prose, multi-language) |
| Cost | Often free |
| Maintenance | Low–Medium (breaks on wording changes) |
A fine manual alert. As a bot's primary signal, the latency floor and the prose-parsing are the limiters.
Method 3: Scraping Twitter/X for exchange announcement accounts
Exchanges announce on X. So watch the official accounts and react to new posts.
# Conceptually: poll a timeline / use a streaming layer, then parse the tweet text def on_tweet(tweet): if tweet.author in OFFICIAL_ACCOUNTS and looks_like_listing(tweet.text): ticker = extract_ticker(tweet.text) route_order(ticker) The honest pros: it's the canonical public source, it's where humans see the news, and the official accounts genuinely do post listings. If you want a confirmation channel or a sanity cross-check, X is reasonable.
The honest cons: as a low-latency machine input it's the weakest of the bunch. Public competitor ranges for Twitter/X pipelines land around 2–10 seconds end to end, because you're stacking API/scraping delays on top of whatever propagation X itself adds — and the exchange often posts on its own site first anyway. API access is expensive and rate-limited, scraping is a cat-and-mouse maintenance treadmill, and you're once again parsing free-form text (now with marketing copy and emojis in the mix). By the time a tweet reaches you, the faster methods have already fired.
| Score | |
|---|---|
| Latency | Poor (~2–10 s) |
| Coverage | Medium (only what's tweeted, when it's tweeted) |
| Reliability | Low–Medium (API cost / scraping breakage) |
| Structured output | Poor (marketing prose) |
| Cost | High (API) or high-maintenance (scraping) |
| Maintenance | High |
Great as a human's news feed. For a sniping bot, treat it as backup, not primary.
Method 4: Build your own WebSocket pipeline
If you have the engineering appetite, you build the whole thing: your own detectors against each exchange, your own parsing, your own low-latency fan-out to your bots over WebSocket.
import asyncio, websockets, json async def fanout(): async with websockets.serve(handler, "0.0.0.0", 8765): await asyncio.Future() # your bots connect here # Upstream: your detectors emit normalized events that your fan-out layer broadcasts # {"exchange":"binance","type":"futures_listing","ticker":"XYZ","ts":...} The honest pros: it's the only way to fully own your latency floor and your coverage. No third party in the path, no per-seat fee, total control over what counts as an event and how it's normalized. If your edge is large enough to justify a dedicated team, this is the ceiling.
The honest cons: it's a real product, not a weekend project. You're now running detectors per exchange, handling Korean and English (and the structural quirks of each exchange's announcement system), and you need serious infrastructure and 24/7 operation for when an exchange changes something at 3am. Most teams underestimate this by an order of magnitude.
| Score | |
|---|---|
| Latency | Best (you own the floor) |
| Coverage | As good as you build |
| Reliability | As good as you operate it 24/7 |
| Structured output | Excellent (you define the schema) |
| Cost | High (engineering + infra + on-call) |
| Maintenance | Very high |
The right answer if and only if the edge funds a team that does this and nothing else.
Method 5: A purpose-built listing WebSocket API
This is the "buy instead of build Method 4" option, and it's the one we operate — CLW (cryptolisting.ws). We make this data feed, so weigh accordingly and benchmark it yourself.
The idea is you skip the detectors, the parsing, the hosting, and the on-call, and you just open a socket and get normalized events: listing / delisting / airdrop / caution / monitoring-tag, across Binance, Upbit, Bithumb and Robinhood, the instant they're published.
We combine various detection methods, and the goal is simple: be faster than the exchanges' official announcement feeds, and faster than everyone else.
import asyncio, json, websockets # websockets>=14 API_KEY = "YOUR_KEY" async def main(): # Auth is via the X-API-Key header (query-param auth is rejected 401). # Filter the Tokyo feed by exchange with ?cex= url = "wss://jp.cryptolisting.ws?cex=binance,upbit" async with websockets.connect(url, additional_headers={"X-API-Key": API_KEY}) as ws: async for raw in ws: ev = json.loads(raw) if ev.get("type") != "announcement": continue # welcome, heartbeat, changelog... are not events # already structured: no prose parsing if ev["listingType"] in ("spot_listing", "futures_listing"): for ticker in ev["ticker"].split(","): # one notice can carry several tokens route_order(ticker, ev["publisher"], ev["listingType"]) asyncio.run(main()) A few things that matter for the benchmark:
- Structured output by default. You get a ticker / type / exchange, not a tweet you have to regex. That alone removes a whole class of silent parser-breakage from your system.
- Coverage across four publishers (Binance, Upbit, Bithumb and Robinhood), including the less-obvious event types (caution releases, monitoring-tag add/remove, HODLer airdrops, Robinhood's "added to assets" and "tradable" events), so you're not hand-rolling four scrapers in two languages.
- Three regional endpoints. Tokyo (
wss://jp.cryptolisting.ws: Binance + Upbit + Bithumb, filterable via?cex=binance,upbit), Seoul (wss://kr.cryptolisting.ws: Upbit + Bithumb, so Korea-targeted bots can connect close to the source) and N. Virginia (wss://us.cryptolisting.ws: Robinhood). Same API key on all three. - Verifiable before you pay. The SpeedTrial tier sends the same events as the paid tiers, 1 ms later so paying subscribers are served first, with the ticker and title redacted. That sounds like a downside until you realize why it's there: you can connect on the SpeedTrial tier and measure detection-to-dispatch latency against your own clock — and against any of Methods 1–4 — before you spend anything. You're not trusting a marketing number; you're timing the real socket. (If you want the actual title and ticker for free, there's also a FreeDelayed tier that ships the full feed at a +240 ms delay.)
On latency, I'll deliberately not quote a millisecond figure for our own feed, because we don't publish one and I'm not going to invent one in a benchmark post — that would defeat the entire point. The honest framing: it's built to be the fastest publicly-available option (faster than the Telegram 150–500 ms and X 2–10 s ranges, and not bounded by a poll interval like Method 1). Go confirm that on the SpeedTrial tier. If it isn't faster than what you're running, you'll know in an afternoon and you've lost nothing.
The honest cons, because every method has them: it's a third party in your path (same category of dependency as Method 2's channel, just purpose-built and structured), and the zero-delay tier is a paid subscription (350 USDT/month for Binance or Bithumb, 750 for Upbit or Robinhood) rather than something you run yourself. If your philosophy is "own every millisecond of the stack," Method 4 is your answer and that's a legitimate choice.
| Score | |
|---|---|
| Latency | Best public option (verify on SpeedTrial tier) |
| Coverage | Good (4 publishers, all event types) |
| Reliability | Good (operated since April 2026, three regions) |
| Structured output | Excellent (normalized schema) |
| Cost | SpeedTrial (free, redacted) / FreeDelayed (full, +240 ms, first month free) → paid from 200 USDT per exchange per month, published |
| Maintenance | Near-zero (it's the vendor's problem) |
There are code examples in Python / Node / Go / Rust in the docs, and a live public feed at /latest-listings/ if you want to eyeball what the events look like before wiring anything.
The summary matrix
Stacking all five side by side:
| Method | Latency | Coverage | Reliability | Structured | Cost | Maintenance |
|---|---|---|---|---|---|---|
| 1. REST polling | Poor (poll-bound) | Medium | Medium | Poor | Free $ | High |
| 2. Telegram bot | Medium (~150–500 ms) | Med–Good | Medium | Poor | Often free | Low–Med |
| 3. Twitter/X scrape | Poor (~2–10 s) | Medium | Low–Med | Poor | High | High |
| 4. DIY WebSocket | Best | As built | As operated | Excellent | High | Very high |
| 5. Listing WS API | Best public | Good | Good | Excellent | Free to test (SpeedTrial; FreeDelayed first month) → from 200 USDT/exchange/month, public | Near-zero |
What I'd actually pick
It honestly depends on what you're optimizing:
- Learning / one exchange / no money: Method 1 (REST polling). You'll understand the problem deeply, and that understanding is worth more than the latency you lose.
- Manual or semi-automated trading: Method 2 (Telegram). The latency floor is fine for a human-in-the-loop, and it's free.
- A confirmation/cross-check channel: Method 3 (X), never as primary.
- You have a dedicated team and the edge justifies it: Method 4 (DIY). Own the whole stack, accept the on-call.
- You want Method 4's latency and structure without Method 4's payroll: Method 5 (a purpose-built API). And because there's a SpeedTrial tier that redacts the content while leaving the timing measurable, 1 ms behind the paid tiers (plus a FreeDelayed tier, free for the first month, that keeps the content at a +240 ms delay), you can settle the latency argument empirically instead of arguing about it in a comments section.
That last point is the one I'd push hardest, regardless of which vendor you end up choosing: don't pick an ingestion method based on a number in a blog post — including this one. Wire two or three of these into the same bot, log the arrival timestamp of the same real listing event, and let the data decide. For our part, that's exactly why the SpeedTrial tier exists.
If you want to run that experiment against us specifically, the docs have the quick-start and the auth details, pricing explains the tiers and publishes the prices, and you can reach us on Telegram @CLWebsocket (API keys and support), by e-mail at contact@cryptolisting.ws or on X @cryptolistingws; the free announcement channel is @CLWfeed. Build the benchmark, then trust the benchmark.
Disclosure: we build CLW (cryptolisting.ws), one of the five options above. It's a data feed, not financial advice.