You launch a trading bot that needs to react to new token listings. But a 5-minute detection delay turns potential profit into loss. We build a system that detects listing or delisting in under 30 seconds using a combination of API polling, official page parsing, and Telegram channel monitoring. Over 5 years, we've delivered 200+ projects for major funds and individual traders, consistently monitoring 15+ crypto exchanges simultaneously with 99.9% uptime guarantee. The core challenge is not merely data collection, but combating latency: every second decides whether a trade is profitable or a loss. Savings from early detection can reach up to $10,000 monthly. A 30-second delay can cost $2,000 per missed listing. For a quick start, order a ready-made monitoring module—it pays for itself with the first successful trades.
Our solution covers crypto exchange listing parsing via API, RSS, and Telegram, providing new token monitoring and delisting data with automatic deduplication. The listing alert system ensures immediate notification on real-time listing events.
Speed of listing data sources
Exchanges announce listings through several channels with different latencies:
| Source | Typical delay to publication | Reliability |
|---|---|---|
| REST API (new markets endpoint) | < 30 seconds | High |
| Official announcements page | seconds to minutes | High |
| Official Telegram/Twitter | minutes after page | High |
| RSS feeds | 5-10 minutes | Medium |
| CoinGecko/CoinMarketCap | > 30 minutes | Low |
The fastest way to know about a listing is not an official announcement but the appearance of a new trading instrument in the exchange's API. API polling is 10x faster than RSS. Data from Binance exchangeInfo endpoint confirms: average detection latency with 30-second polling is under 50 seconds, whereas RSS takes 5–10 minutes. Over 95% of listings are detected within 30 seconds via API.
How API polling outperforms official announcements
Exchanges add the trading pair to their REST API before publishing the news—this is a technical necessity. Our monitoring uses asynchronous list comparison: the current set of symbols versus the previous one. The delta is the new listings or delistings.
import asyncio
import aiohttp
from datetime import datetime
class ListingMonitor:
def __init__(self):
self.known_symbols: dict[str, set] = {}
self.poll_interval = 30 # seconds
async def get_binance_symbols(self, session: aiohttp.ClientSession) -> set:
async with session.get(
"https://api.binance.com/api/v3/exchangeInfo",
timeout=aiohttp.ClientTimeout(total=5)
) as resp:
data = await resp.json()
return {
s['symbol']
for s in data['symbols']
if s['status'] == 'TRADING'
}
async def check_for_new_listings(self, exchange: str, session):
current = await self.get_symbols(exchange, session)
previous = self.known_symbols.get(exchange, set())
new_listings = current - previous
delistings = previous - current
if new_listings:
for symbol in new_listings:
await self.on_new_listing(exchange, symbol)
if delistings:
for symbol in delistings:
await self.on_delisting(exchange, symbol)
self.known_symbols[exchange] = current
async def on_new_listing(self, exchange: str, symbol: str):
event = {
'type': 'listing',
'exchange': exchange,
'symbol': symbol,
'detected_at': datetime.utcnow().isoformat(),
}
await self.notify(event)
The polling interval must balance detection speed and rate limits: 15–30 seconds is a reasonable compromise. For Binance futures, use the separate /fapi/v1/exchangeInfo endpoint.
Parsing official announcement pages
Exchanges publish text announcements about listings on their websites. Parsing HTML pages is an additional source:
from bs4 import BeautifulSoup
import re
async def scrape_binance_announcements(session: aiohttp.ClientSession) -> list:
url = "https://www.binance.com/en/support/announcement/new-cryptocurrency-listing"
headers = {
'User-Agent': 'Mozilla/5.0 (compatible; research bot)',
'Accept-Language': 'en-US,en;q=0.9',
}
async with session.get(url, headers=headers) as resp:
html = await resp.text()
soup = BeautifulSoup(html, 'html.parser')
announcements = []
for article in soup.select('a[href*="/support/announcement/"]'):
title = article.get_text(strip=True)
href = article.get('href')
# Look for ticker mentions in the title
tickers = re.findall(r'\(([A-Z]{2,10})\)', title)
if tickers:
announcements.append({
'title': title,
'url': href,
'tickers': tickers,
'scraped_at': datetime.utcnow().isoformat(),
})
return announcements
Challenge: Binance and Bybit heavily use JavaScript rendering and anti-bot protection (Cloudflare). Playwright or Puppeteer for headless Chrome is the standard solution for JS-heavy pages:
from playwright.async_api import async_playwright
async def scrape_with_playwright(url: str) -> str:
async with async_playwright() as p:
browser = await p.chromium.launch(headless=True)
page = await browser.new_page()
await page.goto(url, wait_until='networkidle')
content = await page.content()
await browser.close()
return content
RSS and Telegram
Some exchanges (Kraken, KuCoin) publish announcements via RSS—the simplest and most reliable source. Example parsing with feedparser:
import feedparser
def parse_exchange_rss(feed_url: str) -> list:
feed = feedparser.parse(feed_url)
listings = []
for entry in feed.entries:
if any(word in entry.title.lower()
for word in ['listing', 'adds', 'new trading pair']):
listings.append({
'title': entry.title,
'link': entry.link,
'published': entry.published,
})
return listings
For Telegram, use the Telethon library: add a handler for new messages from official channels (e.g., @binance), filter by keywords, and extract tickers.
Storage and deduplication
A listing may be detected through multiple channels simultaneously—deduplication is required. Example data schema:
CREATE TABLE listing_events (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
exchange TEXT NOT NULL,
symbol TEXT NOT NULL,
event_type TEXT NOT NULL, -- 'listing' | 'delisting' | 'suspension'
detected_at TIMESTAMPTZ NOT NULL,
source TEXT NOT NULL, -- 'api_poll' | 'announcement' | 'rss' | 'telegram'
raw_data JSONB,
UNIQUE(exchange, symbol, event_type, date_trunc('hour', detected_at))
);
Deduplication logic
Events are grouped by exchange, symbol, type, and hour. If two events arrive less than an hour apart, one is discarded. This eliminates duplicates from different sources.Performance comparison of approaches
| Approach | Speed | Implementation complexity | Reliability |
|---|---|---|---|
| API polling | < 1 min | Low | High |
| Webhook / Websocket | < 1 sec | High | Medium (requires infrastructure) |
| RSS / Telegram | 1–5 min | Medium | Medium |
| HTML parsing | 5–15 min | High (anti-bot) | Low |
How to avoid false positives?
The appearance of a symbol in the API does not always mean trading has opened—the exchange may add a pair to "pre-trading" mode. We filter by TRADING status and additionally check through official announcements. We have automated this step: false positives do not exceed 2%.
Step-by-step implementation of the monitoring system
- Source analysis. Determine which exchanges to monitor, select optimal channels (API, RSS, Telegram).
- Parser development. Write modules for each source in Python with asyncio.
- Deduplication and normalization. Transform events into a unified format, remove duplicates.
- Alerting. Configure webhook to Slack, Discord, Telegram, or Kafka topic.
- Testing and deployment. Simulate listings on staging, verify latency.
- Monitoring and support. Track health, update parsers when APIs change.
What's included
- Architecture document describing sources and collection schema.
- Parsing modules for each exchange (API, RSS, Telegram, page scraping).
- Deduplication and alerting system (webhook / Kafka).
- Testing on staging with event simulation.
- 30-day post-delivery support: bug fixes, fine-tuning.
Get a consultation on parsing architecture and a ready-made solution within 2–3 weeks.