How to export Upbit's historical K-line data?

To export Upbit's historical K-line data, set up Python, use the Upbit API's candles endpoint, handle pagination, and save the data in CSV format.

Apr 15, 2025 at 09:01 pm

How to Export Upbit's Historical K-line Data?

Exporting historical K-line data from Upbit can be crucial for traders and analysts who need to study market trends and make informed trading decisions. Upbit, being one of the largest cryptocurrency exchanges in South Korea, provides a wealth of data that can be accessed through its API. In this article, we will guide you through the process of exporting Upbit's historical K-line data in detail.

Understanding Upbit's API

Before diving into the steps for exporting data, it's important to understand the basics of Upbit's API. Upbit's API allows users to access real-time and historical market data, place orders, and manage their accounts programmatically. For exporting historical K-line data, we will focus on the candles endpoint, which provides the necessary information in the form of candlestick data.

Setting Up Your Environment

To begin, you will need to set up your development environment. Here are the steps to do so:

• Install Python: Ensure you have Python installed on your system. You can download it from the official Python website if you haven't already.

• Install Required Libraries: You will need to install the requests library to make HTTP requests to the Upbit API. You can install it using pip:

  pip install requests

• API Access: You will need to create an API key on Upbit's website. Navigate to the API management section, create a new key, and keep the API key and secret safe.

Making API Requests

Once your environment is set up, you can start making API requests to retrieve the historical K-line data. Here's how to do it:

• Import Required Libraries: Start by importing the necessary libraries in your Python script.

  import requests
  import json
  from datetime import datetime, timedelta

• Define API Endpoint: The endpoint for retrieving candles is https://api.upbit.com/v1/candles/minutes/{unit}. Here, {unit} can be 1, 3, 5, 10, 15, 30, 60, or 240, representing the time interval of each candle in minutes.

• Set Parameters: You need to set parameters such as the market (e.g., KRW-BTC), the candle unit, and the date range. For example, to retrieve 1-minute candles for KRW-BTC over the last 24 hours, you can set the parameters as follows:

  market = "KRW-BTC"
  unit = 1
  to = datetime.now()
  from_ = to - timedelta(days=1)

• Construct the URL: Combine the endpoint and parameters to construct the URL for the API request.

  url = f"https://api.upbit.com/v1/candles/minutes/{unit}?market={market}&to={to.isoformat()}&count=200"

• Send the Request: Use the requests library to send a GET request to the constructed URL.

  response = requests.get(url)
  data = response.json()

Processing and Saving the Data

After receiving the data, you need to process it and save it in a suitable format. Here's how to do that:

• Parse the Data: The data received will be in JSON format. You can parse it and extract the relevant information such as timestamp, opening price, high price, low price, closing price, and trading volume.

  for candle in data:
  timestamp = candle['candle_date_time_utc']
  opening_price = candle['opening_price']
  high_price = candle['high_price']
  low_price = candle['low_price']
  closing_price = candle['trade_price']
  volume = candle['candle_acc_trade_volume']
  # Process the data as needed

• Save the Data: You can save the processed data in various formats such as CSV, JSON, or even a database. Here's an example of saving it as a CSV file:

  import csv
  

  with open('upbit_kline_data.csv', 'w', newline='') as csvfile:

  fieldnames = ['timestamp', 'opening_price', 'high_price', 'low_price', 'closing_price', 'volume']
  writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
  writer.writeheader()
  for candle in data:
      writer.writerow({
          'timestamp': candle['candle_date_time_utc'],
          'opening_price': candle['opening_price'],
          'high_price': candle['high_price'],
          'low_price': candle['low_price'],
          'closing_price': candle['trade_price'],
          'volume': candle['candle_acc_trade_volume']
      })

Handling Pagination

Upbit's API has a limit on the number of candles it returns in a single request. To retrieve more data, you need to handle pagination. Here's how to do it:

• Initial Request: Make the initial request as described earlier.

• Check for More Data: Check if there are more candles available by looking at the timestamp of the last candle in the response.

• Subsequent Requests: Use the timestamp of the last candle to make subsequent requests. Update the to parameter in the URL to the timestamp of the last candle received.

  while data:
  last_timestamp = data[-1]['candle_date_time_utc']
  url = f"https://api.upbit.com/v1/candles/minutes/{unit}?market={market}&to={last_timestamp}&count=200"
  response = requests.get(url)
  new_data = response.json()
  if new_data:
      data.extend(new_data)
  else:
      break

Error Handling and Best Practices

When working with APIs, it's important to implement error handling and follow best practices. Here are some tips:

• Error Handling: Use try-except blocks to handle potential errors such as network issues or API rate limits.

  try:
  response = requests.get(url)
  response.raise_for_status()

  except requests.exceptions.RequestException as e:

  print(f"Error occurred: {e}")

• Rate Limiting: Be mindful of Upbit's rate limits. Implement delays between requests if necessary to avoid hitting the rate limit.

  import time
  

  time.sleep(1) # Wait for 1 second between requests

• Data Validation: Validate the data received from the API to ensure it meets your expectations.

  if not data:
  print("No data received")
  else:
  for candle in data:
      if 'candle_date_time_utc' not in candle:
          print("Invalid data format")
          break

Frequently Asked Questions

Q: Can I export historical K-line data for multiple cryptocurrencies at once?

A: Upbit's API does not support batch requests for multiple markets in a single API call. You will need to make separate requests for each cryptocurrency you are interested in.

Q: How far back can I retrieve historical K-line data from Upbit?

A: Upbit provides historical data for up to two years for most markets. However, the availability of data may vary depending on the specific market and candle unit.

Q: Is there a limit on the number of API requests I can make per day?

A: Yes, Upbit has rate limits on its API. The exact limits depend on your API key type. It's important to check the documentation and implement proper rate limiting in your code to avoid hitting these limits.

Q: Can I use the exported data for commercial purposes?

A: It's essential to review Upbit's terms of service and API usage policy to understand any restrictions on using the data for commercial purposes. Always ensure compliance with their policies.