All cryptocurrency exchanges API

The simplest and the most efficient way to access all crypto APIs data to build powerful applications.

Start now Contact sales

Data coverage

Highest precision data from all cryptocurrency exchanges with convenient access from a single API with a single format.

Real time & historical

All crypto pairs are available for real-time low latency streaming. Furthermore profound historical crypto market data is provided.

Unlimited use cases

Build a wide range of products with our data solutions such as charting apps, mobile apps, trading bots, backtests, etc.

Ease of integration

Use the data in JSON, CSV formats, and WebSocket for real-time streaming, with direct connection or using our SDKs.

Complete coverage

Crypto exchanges as is

Access 180+ cryptocurrency exchanges with 10,000+ exchange rates in total. All the data is checked by AI algorithms to get rid of distortions. This list is constantly updated to adopt new markets.

YoBit
Binance
HitBTC
CoinExchange
OKEx
Bittrex
Livecoin
Kucoin
Gate.io
Huobi

Upbit
EtherDelta
Tidex
Hotbit
Bibox
Poloniex
Bitfinex
Mercatox
IDEX
Coinbene

Coinbase
BitStamp
Kraken
Gemini
OKCoin
GDAX
Bit-Z
LATOKEN
Exmo
BigONE

BitForex
p2pb2b
ZB.COM
Crex24
Bitrue
CoinEx
Exrates
COINEGG
BitMart
Ethfinex

Not all exchanges are displayed

Single platform

Developer-centric

Rapidly integrate our cryptocurrency exchange data into your project with modern languages, from Python to Golang. Using Twelve Data's API means less code maintenance and more time towards building a great product.

Same request and response structure for all exchanges
HTTP RESTful API supports JSON and CSV formats
Real-time market data streaming via WebSocket
World-class documentation with various SDKs
OHLC values aggregated for multiple intervals

API docs WebSocket docs

            
                 API
            
            
                 WebSocket
            
        

from twelvedata import TDClient
 
td = TDClient(apikey="YOUR_API_KEY_HERE")
 
ts = td.time_series(
    symbol="TSLA",
    interval="1min",
    outputsize=12,
)
 
print(ts.as_json())
 


#include <cjson/cJSON.h> // https://github.com/DaveGamble/cJSON
#include <curl/curl.h>
#include <iostream>
#include <memory>
 
const char* REQUEST_URL = "https://api.twelvedata.com/time_series?symbol=TSLA&interval=1min&outputsize=12&apikey=YOUR_API_KEY_HERE";
 
// Take response data and write into the string
std::size_t write_callback(const char* data, std::size_t size, std::size_t count, std::string* out) {
    const std::size_t result = size * count;
    out->append(data, result);
 
    return result;
}
 
int main() {
    std::unique_ptr<std::string> responseData(new std::string());
    cJSON* json = nullptr;
    CURL* curl = curl_easy_init();
 
    curl_easy_setopt(curl, CURLOPT_URL, REQUEST_URL);
    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, responseData.get());
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_perform(curl);
 
    json = cJSON_Parse(responseData->c_str());
    cJSON* metaField = cJSON_GetObjectItem(json, "meta");
    cJSON* valuesField = cJSON_GetObjectItem(json, "values");
    cJSON* symbolField = cJSON_GetObjectItem(metaField, "symbol");
    cJSON* closeField = cJSON_GetObjectItem(cJSON_GetArrayItem(valuesField, 0), "close");
 
    std::cout << "Received symbol: " << cJSON_GetStringValue(symbolField) << ", ";
    std::cout << "close: " << cJSON_GetStringValue(closeField) << std::endl;
 
    cJSON_Delete(json);
    curl_easy_cleanup(curl);
 
    return 0;
}
 


using System;
using System.Collections.Generic;
using System.Net;
using System.Text.Json;
 
namespace TwelveData
{
    public class TimeSeries
    {
        public Dictionary<string, string> meta { get; set; }
        public IList<Dictionary<string, string>> values { get; set; }
        public string status { get; set; }
    }
 
    class Prices
    {
        static void Main(string[] args)
        {
            using WebClient wc = new WebClient();
            var response = wc.DownloadString("https://api.twelvedata.com/time_series?symbol=TSLA&interval=1min&outputsize=12&apikey=YOUR_API_KEY_HERE");
            var timeSeries = JsonSerializer.Deserialize<TimeSeries>(response);
            if (timeSeries.status == "ok")
            {
                Console.WriteLine("Received symbol: " + timeSeries.meta["symbol"] + ", close: " + timeSeries.values[0]["close"]);
            }
        }
    }
}
 


import org.json.simple.parser.JSONParser;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
 
import java.util.Scanner;
import java.net.HttpURLConnection;
import java.net.URL;
 
public class Main {
    private static final String REQUEST_URL = "https://api.twelvedata.com/time_series?symbol=TSLA&interval=1min&outputsize=12&apikey=YOUR_API_KEY_HERE";
 
    public static void main(String[] args) throws Exception {
        URL requestURL = new URL(REQUEST_URL);
        HttpURLConnection connection = (HttpURLConnection)requestURL.openConnection();
        StringBuffer responseData = new StringBuffer();
        JSONParser parser = new JSONParser();
 
        connection.setRequestMethod("GET");
        connection.setRequestProperty("User-Agent", "twelve_java/1.0");
        connection.connect();
 
        if (connection.getResponseCode() != 200) {
            throw new RuntimeException("Request failed. Error: " + connection.getResponseMessage());
        }
 
        Scanner scanner = new Scanner(requestURL.openStream());
        while (scanner.hasNextLine()) {
            responseData.append(scanner.nextLine());
        }
 
        JSONObject json = (JSONObject) parser.parse(responseData.toString());
        JSONObject meta = (JSONObject) json.get("meta");
        JSONArray values = (JSONArray) json.get("values");
        
        connection.disconnect();
    }
}
 


# install.packages("RcppSimdJson")
 
apikey <- "YOUR_API_KEY_HERE"
qry <- paste0(
        "https://api.twelvedata.com/time_series?",
        "symbol=AAPL&interval=1min&outputsize=12",
        "&apikey=", apikey)
res <- RcppSimdJson::fload(qry)
res
 


# pip install twelvedata[websocket]
 
from twelvedata import TDClient
 
def on_event(e):
    print(e)
 
td = TDClient(apikey="YOUR_API_KEY_HERE")
ws = td.websocket(symbols="TSLA", on_event=on_event)
ws.connect()
ws.keep_alive()
 


#include <websocketpp/config/asio_client.hpp>
#include <websocketpp/client.hpp>
#include <cjson/cJSON.h>
 
#include <iostream>
#include <iomanip>
#include <ctime>
 
namespace wlib = websocketpp::lib;
namespace ssl = boost::asio::ssl;
 
typedef websocketpp::client<websocketpp::config::asio_tls_client> wclient;
typedef wlib::shared_ptr<wlib::asio::ssl::context> context_ptr;
 
const char* ENDPOINT = "wss://ws.twelvedata.com/v1/quotes/price?apikey=YOUR_API_KEY_HERE";
 
const char* SUBSCRIBE_ACTION = "{"\
    "\"action\": \"subscribe\"," \
    "\"params\": {" \
        "\"symbols\": \"TSLA\"" \
    "}" \
"}";
 
int main() {
    wclient::connection_ptr connection;
    wlib::error_code error_code;
    wclient client;
    
    client.set_access_channels(websocketpp::log::alevel::all);
    client.clear_access_channels(websocketpp::log::alevel::frame_payload);
    client.set_error_channels(websocketpp::log::elevel::all);
 
    // Initialize Boost.ASIO
    client.init_asio();
 
    // Set TLS initialize handler
    client.set_tls_init_handler(wlib::bind([](auto* hostname, auto hdl) {
        context_ptr context = wlib::make_shared<ssl::context>(ssl::context::sslv23);
        context->set_verify_mode(ssl::verify_none);
 
        return context;
    }, ENDPOINT, websocketpp::lib::placeholders::_1));
 
    // Is called after the WebSocket handshake is complete
    client.set_open_handler([&client](auto hdl) {
        // Send subscribe action to stream
        client.send(hdl, SUBSCRIBE_ACTION, websocketpp::frame::opcode::text);
    });
 
    // Receive and handle messages from server
    client.set_message_handler([](auto hdl, wclient::message_ptr message) {
        cJSON* json = cJSON_Parse(message->get_payload().c_str());
 
        if (json == nullptr) {
            std::cout << "received invalid JSON: " << std::endl << message->get_payload() << std::endl;
            return;
        }
 
        // Get event type
        cJSON* eventTypeField = cJSON_GetObjectItem(json, "event");
        if (eventTypeField == nullptr) {
            std::cout << "unknown JSON structure" << std::endl;
            return;
        }
 
        // Extract string from event type
        const char* eventType = cJSON_GetStringValue(eventTypeField);
        if (strcmp(eventType, "subscribe-status") == 0) {
            cJSON* statusField = cJSON_GetObjectItem(json, "status");
            const char* status = cJSON_GetStringValue(statusField);
 
            if (strcmp(status, "ok") != 0) {
                std::cout << "Failed subscribe to stream" << std::endl;
                return;
            }
 
            cJSON* successField = cJSON_GetObjectItem(json, "success");
            cJSON* failsField = cJSON_GetObjectItem(json, "fails");
 
            // Iterate over the symbols that were successfully subscribed
            for (int idx = 0; idx < cJSON_GetArraySize(successField); idx++) {
                cJSON* item = cJSON_GetArrayItem(successField, idx);
                cJSON* symbolField = cJSON_GetObjectItem(item, "symbol");
                const char* symbol = cJSON_GetStringValue(symbolField);
 
                std::cout << "Success subscribed to `"<< symbol << "` " << "symbol." << std::endl;
            }
 
            // If we're unable to subscribe to some symbols
            for (int idx = 0; 0 < cJSON_GetArraySize(failsField); idx++) {
                cJSON* item = cJSON_GetArrayItem(failsField, idx);
                cJSON* symbolField = cJSON_GetObjectItem(item, "symbol");
                const char* symbol = cJSON_GetStringValue(symbolField);
 
                std::cout << "Failed to subscribe on `"<< symbol << "` " << "symbol." << std::endl;
            }
 
            return;
        }
 
        if (strcmp(eventType, "price") == 0) {
            cJSON* timestampField = cJSON_GetObjectItem(json, "timestamp");
            cJSON* currencyField = cJSON_GetObjectItem(json, "currency");
            cJSON* symbolField = cJSON_GetObjectItem(json, "symbol");
            cJSON* priceField = cJSON_GetObjectItem(json, "price");
            time_t time = timestampField->valueint;
 
            std::cout << "[" << std::put_time(gmtime(&time), "%I:%M:%S %p") << "]: ";
            std::cout << "The symbol `" << cJSON_GetStringValue(symbolField) << "` ";
            std::cout << "has changed price to " << priceField->valuedouble << " ";
            
            if (currencyField != nullptr) {
                std::cout << "(" << cJSON_GetStringValue(currencyField) << ")" << std::endl;
            } else {
                std::cout << std::endl;
            }
            
            return;
        }
 
        // Free memory of JSON structure
        cJSON_Delete(json);
    });
 
    // New connection to WebSocket endpoint
    connection = client.get_connection(ENDPOINT, error_code);
    if (error_code) {
        std::cout << "Failed connection. Message: " << error_code.message() << std::endl;
        return -1;
    }
 
    // Connect to websocket endpoint
    client.connect(connection);
    client.run();
}
 


using System;
using WebSocket4Net; //https://github.com/kerryjiang/WebSocket4Net
 
namespace TwelveData
{
    class TDWebSocket
    {
        WebSocket ws = new WebSocket("wss://ws.twelvedata.com/v1/quotes/price?apikey=YOUR_API_KEY_HERE");
 
        static void Main()
        {
            new TDWebSocket().Init();
        }
 
        public void Init()
        {
            ws.Opened += OnOpen;
            ws.Closed += OnClose;
            ws.Error += OnError;
            ws.MessageReceived += OnEvent;
 
            ws.Open();
            Console.ReadLine();
        }
 
        private void OnOpen(object sender, EventArgs e)
        {
            Console.WriteLine("TDWebSocket opened!");
            ws.Send("{\"action\": \"subscribe\", \"params\":{\"symbols\": \"TSLA\"}}");
        }
 
        private void OnClose(object sender, EventArgs e)
        {
            Console.WriteLine("TDWebSocket closed");
        }
 
        private void OnError(object sender, SuperSocket.ClientEngine.ErrorEventArgs e)
        {
            Console.WriteLine("TDWebSocket ERROR: " + e.Exception.Message);
        }
 
        private void OnEvent(object sender, MessageReceivedEventArgs e)
        {
            Console.WriteLine(e.Message);
        }
    }
}
 


import org.java_websocket.handshake.ServerHandshake;
import org.java_websocket.client.WebSocketClient;
 
import org.json.simple.parser.ParseException;
import org.json.simple.parser.JSONParser;
import org.json.simple.JSONObject;
 
import java.net.URI;
 
public class Main {
    private static final String ENDPOINT = "wss://ws.twelvedata.com/v1/quotes/price?apikey=YOUR_API_KEY_HERE";
 
    public static void main(String[] args) throws Exception {
        WebSocketClient client = new WebSocketClient(new URI(ENDPOINT)) {
            @Override
            public void onOpen(ServerHandshake handshake) {
                System.out.println("TDWebSocket opened!");
                send("{\"action\": \"subscribe\", \"params\":{\"symbols\": \"TSLA\"}}");
            }
 
            @Override
            public void onMessage(String message) {
                JSONParser parser = new JSONParser();
                try {
                    JSONObject json = (JSONObject) parser.parse(message);
                    System.out.println(json);
                } catch(ParseException e) {
                    e.printStackTrace();
                }
            }
 
            @Override
            public void onClose(int status, String reason, boolean remote) {
                System.out.println("TDWebSocket closed.");
                this.close();
            }
 
            @Override
            public void onError(Exception e) {
                e.printStackTrace();
            }
        };
 
        client.connectBlocking();
    }
}
 


# install.packages("websocket")
 
library(websocket)
 
ws <- WebSocket$new("wss://ws.twelvedata.com/v1/quotes/price?apikey=YOUR_API_KEY_HERE")
ws$onOpen(function(event) {
    cat("TDWebSocket opened!\n")
})
ws$onClose(function(event) {
    cat("TDWebSocket closed with code ", event$code,
        " and reason ", event$reason, "\n", sep = "")
})
ws$onError(function(event) {
    cat("TDWebSocket ERROR: ", event$message, "\n")
})
ws$onMessage(function(event) {
    cat("Received event:", event$data, "\n")
})
 
ws$send('{"action": "subscribe", "params":{"symbols": "TSLA"}}')
 

 

            
                Python
            






            
                C++
            
            
                C#
            
            
                Java
            
            
                R
            
        

Strong backbone

Create powerful cryptocurrency applications

Search

Easily add a lookup of any symbol into your app with the most effective search in the industry.

Explore

Technical indicators

Extensive collection of indicators, ready to be used for technical analysis.

Explore

Backtesting & ML

Terabytes of historical data make our API a great option for backtesting & ML model training.

Explore

Charts

Highly accurate crypto data for various intervals are great for displaying reliable info to users.

Explore

Institutional grade infrastructure. Designed to scale.

100,000,000+

Requests per day

10,000+

Pairs available

70,000+

Events per second

Curious, but not a developer?

We love our products and the way it empowers new stories.
We can help you to build projects of any difficulty, to deliver the highest quality.

Our expertise Our customers

Ready to get started? Get in touch or create an account.

Access the world currency exchange rates with the forex data API.

Start now Contact sales

Simple pricing

Pay for what you need. No hidden or implicit fees.

Pricing

Begin with API

Integrate Twelve Data in as little as 5 minutes.

Docs