Bithumb WebSocket — market data vs listing announcements

Searching for the Bithumb WebSocket usually means one of two things: you want live market data (ticker, trades, order book) for pairs that already trade — or you want to know the second Bithumb announces a new listing or an investment-caution notice. Bithumb's public socket does the first. It does not do the second. This guide covers both, with runnable code.

Two sockets, two jobs

Bithumb's public market-data WebSocket

Bithumb currently documents its API 2.x WebSocket at wss://ws-api.bithumb.com/websocket/v1, subscribed Upbit-style with a JSON array — a ticket object plus type objects (ticker, trade, orderbook) with codes like KRW-BTC. The legacy 1.x socket at wss://pubwss.bithumb.com/pub/ws is still live even though it has dropped out of the current docs: you send a JSON message with a type (ticker, transaction, or orderbookdepth) and the symbols you care about — legacy symbols look like BTC_KRW, and for ticker you also pass one or more tickTypes (a window such as 24H).

# pip install "websockets>=14"  (legacy 1.x socket — still live)
import asyncio, json, websockets

async def main():
    url = "wss://pubwss.bithumb.com/pub/ws"
    sub = {"type": "ticker",
           "symbols": ["BTC_KRW", "ETH_KRW"],
           "tickTypes": ["24H"]}
    async with websockets.connect(url) as ws:
        await ws.send(json.dumps(sub))
        async for raw in ws:
            print(json.loads(raw))

asyncio.run(main())

That is exactly what you want for a coin that already trades. But you have to name the symbols up front — which is the whole problem for a coin that isn't listed yet.

Why the public feed can't tell you about new listings

A brand-new Bithumb market has no symbol until it goes live, so there is nothing to subscribe to in advance. Bithumb's listing decisions — and its multi-stage investment-caution lifecycle (designation, extension, release, delisting) — are published as notices, on a channel completely separate from the market-data socket. By the time XYZ_KRW appears in the transaction stream, the initial reaction is usually already underway. The public WebSocket reflects a listing; it doesn't warn you of one.

The announcement WebSocket: catch the notice at publication

CryptoListing.ws runs a dedicated announcement WebSocket that broadcasts a structured JSON event in real time the instant Bithumb publishes a new listing, a caution release, or a delisting. It watches Bithumb's official announcement channel so you don't have to.

# pip install "websockets>=14"  — the header param is additional_headers
# (extra_headers was removed in websockets v14+)
import asyncio, json, websockets

API_KEY = "dsk_your_key_here"
WS_URL  = "wss://cryptolisting.ws?cex=bithumb"

async def run():
    headers = {"X-API-Key": API_KEY}
    async with websockets.connect(WS_URL, additional_headers=headers) as ws:
        async for raw in ws:
            msg = json.loads(raw)
            if msg["type"] == "announcement":
                for ticker in msg["ticker"].split(","):
                    print(msg["listingType"], ticker, msg["title"])

asyncio.run(run())

Message format

Every announcement is a single JSON object. A composite notice covering several tickers arrives split into distinct events, and ticker can still be comma-separated, so always split it.

{
  "type": "announcement",
  "title": "[Market Addition] TOKEN (TOKEN) KRW Market",
  "ticker": "TOKEN",
  "publisher": "bithumb",
  "listingType": "spot_listing",
  "detectedTimestampUs": 1710345000005000,
  "dispatchTimestampUs": 1710345000006000
}

The caution lifecycle, narrowed to what moves price

Bithumb runs a multi-stage investment-caution process on tokens that already trade. Rather than flood you with every intermediate stage, the feed broadcasts the two that are trade-actionable: caution_released (a designation is lifted — often a positive technical signal) and spot_delisting (final removal). That keeps the stream signal, not noise.

Use both feeds together

The two sockets complement each other. Subscribe to the announcement WebSocket to learn that a KRW pair is being added; the moment the event arrives, open Bithumb's public ticker or transaction stream on the new symbol to follow the price.

FAQ

What is the Bithumb WebSocket endpoint?

The current API 2.x socket is wss://ws-api.bithumb.com/websocket/v1 (ticket + type objects, codes like KRW-BTC). The legacy 1.x socket wss://pubwss.bithumb.com/pub/ws is still live: you send a JSON message (type + symbols + tickTypes) and receive JSON responses for symbols that already trade.

Can the public Bithumb WebSocket alert me to new listings?

No — you can only subscribe to symbols that already exist, and listing and caution decisions are published as notices, not on the market socket. For that you need an announcement API.

How do I filter the announcement feed to Bithumb only?

Append ?cex=bithumb to the Tokyo endpoint: wss://cryptolisting.ws?cex=bithumb. You can combine exchanges, e.g. ?cex=bithumb,upbit.

What about Upbit and Binance?

The same feed covers Upbit and Binance. Korea-based bots trading Upbit can also use the Seoul endpoint.