How to use Upbit's WebSocket interface?

Upbit's WebSocket interface offers real-time market data, enabling quick trades; this guide covers setup, subscription, and data handling for efficient trading.

Apr 14, 2025 at 10:35 pm

Using Upbit's WebSocket interface can significantly enhance your ability to receive real-time market data and execute trades with minimal delay. This article will guide you through the process of setting up and using Upbit's WebSocket interface, covering everything from initial connection to handling real-time data.

Understanding Upbit's WebSocket Interface

Upbit's WebSocket interface is designed to provide real-time market data, including order book updates, trade executions, and other critical information. Unlike RESTful APIs, which require periodic polling, WebSocket connections maintain a persistent link, allowing for immediate data transmission as events occur. This is particularly useful for applications requiring real-time updates, such as trading bots and market analysis tools.

Setting Up the WebSocket Connection

To establish a connection with Upbit's WebSocket server, you will need to use a WebSocket client library. Many programming languages offer such libraries, including JavaScript, Python, and Java. Here's how to set up a connection using Python's websocket-client library:

• Install the WebSocket client library: You can do this by running pip install websocket-client in your terminal.
• Import the necessary modules: In your Python script, add import websocket.
• Define the WebSocket URL: Upbit's WebSocket URL is wss://api.upbit.com/websocket/v1.
• Establish the connection: Use the websocket.create_connection() function to connect to the WebSocket URL.

Here is a sample code snippet to establish the connection:

import websocket
ws = websocket.create_connection("wss://api.upbit.com/websocket/v1")

Subscribing to Market Data

Once connected, you need to subscribe to the specific market data you are interested in. Upbit allows you to subscribe to various types of data, such as order book updates, trade ticks, and ticker data.

• Send a subscription request: After establishing the connection, send a JSON-formatted subscription request. For example, to subscribe to the order book of the BTC/KRW pair, you would send:

{
  "type": "subscribe",
  "channels": [
{
  "name": "orderbook",
  "symbols": ["KRW-BTC"]
}
]
}

• Send the subscription request using Python: Use the ws.send() method to send the subscription request.

subscription = {
  "type": "subscribe",
  "channels": [
{
  "name": "orderbook",
  "symbols": ["KRW-BTC"]
}
]
}
ws.send(json.dumps(subscription))

Handling Real-Time Data

Once subscribed, you will start receiving real-time data from Upbit. You need to set up a mechanism to process this data effectively.

• Set up a loop to receive messages: Use a loop to continuously receive messages from the WebSocket connection. In Python, you can use the ws.recv() method to receive data.

import json
while True:
result = ws.recv()
data = json.loads(result)
print(data)
Parse and process the received data: Depending on the type of data received, you will need to parse it and process it accordingly. For example, if you receive order book data, you might want to update your local order book representation.
Managing the Connection
Maintaining a stable WebSocket connection is crucial for real-time applications. Here are some tips for managing the connection:
Implement reconnection logic: If the connection is lost, your application should attempt to reconnect. You can use a try-except block to handle connection errors and attempt to reconnect.
while True:
try:
    ws = websocket.create_connection("wss://api.upbit.com/websocket/v1")
    # Send subscription requests and handle data
except websocket.WebSocketException as e:
    print(f"WebSocket error: {e}")
    time.sleep(5)  # Wait for 5 seconds before retrying
Handle WebSocket ping/pong: Upbit's WebSocket server may send ping messages to keep the connection alive. Ensure your client responds to these pings with pong messages to maintain the connection.
Unsubscribing from Market Data
If you no longer need to receive certain data, you can unsubscribe from it. This helps in managing the data flow and reducing unnecessary network traffic.
Send an unsubscribe request: Similar to subscribing, you need to send a JSON-formatted unsubscribe request. For example, to unsubscribe from the order book of the BTC/KRW pair, you would send:
{
"type": "unsubscribe",
 "channels": [
{
  "name": "orderbook",
  "symbols": ["KRW-BTC"]
}
]
}

• Send the unsubscribe request using Python: Use the ws.send() method to send the unsubscribe request.

unsubscription = {
  "type": "unsubscribe",
  "channels": [
{
  "name": "orderbook",
  "symbols": ["KRW-BTC"]
}
]
}
ws.send(json.dumps(unsubscription))

Closing the WebSocket Connection

When you are done using the WebSocket connection, it's important to close it properly to free up resources.

• Close the connection: Use the ws.close() method to close the WebSocket connection.

ws.close()

Frequently Asked Questions

Q: Can I subscribe to multiple markets at once using Upbit's WebSocket interface?

A: Yes, you can subscribe to multiple markets by including multiple symbols in your subscription request. For example, to subscribe to both BTC/KRW and ETH/KRW order books, you would send:

{
  "type": "subscribe",
  "channels": [
{
  "name": "orderbook",
  "symbols": ["KRW-BTC", "KRW-ETH"]
}
]
}

Q: How can I handle rate limiting with Upbit's WebSocket interface?

A: Upbit's WebSocket interface does not have explicit rate limits like RESTful APIs. However, to avoid overwhelming the server, you should manage your subscriptions and data processing efficiently. If you encounter issues, consider reducing the number of subscriptions or implementing a backoff strategy.

Q: Is it possible to receive both trade and order book data through the same WebSocket connection?

A: Yes, you can subscribe to multiple types of data through the same WebSocket connection. For example, to receive both trade and order book data for BTC/KRW, you would send:

{
  "type": "subscribe",
  "channels": [
{
  "name": "orderbook",
  "symbols": ["KRW-BTC"]
},
{
  "name": "trade",
  "symbols": ["KRW-BTC"]
}
]
}

Q: How can I ensure my WebSocket connection remains stable over long periods?

A: To ensure stability, implement reconnection logic to handle disconnections, manage WebSocket ping/pong messages to keep the connection alive, and monitor your application's performance to avoid resource exhaustion.