Stocks market data JSON API

US & international stock market data with real‑time streaming and historical data API.

Start now Contact sales

A legacy of market data

From early beginnings to today, explore the trends and patterns shaping
every era of the global markets.

Historical range

Starting at each market’s earliest known records—often reaching back decades—up to 1980, with intervals anywhere between daily snapshots and month summaries.

Intraday range

Available from 2022 onward, with intervals from 1 minute to 8 hours. Actual start dates and interval options may vary by market.

Historical range 1 day to 1 month intervals

Intraday range 1 minute to 8 hour intervals

1980 2022 Today

Example for US markets

Tick by tick

Real-time tick by tick data grants full control over the current stock quotes.

Intervals

API data is accessible in various aggregated intervals from 1‑minute to 1-month.

Low latency

Institutional grade low latency (170ms) data streaming via WebSocket.

Simple integration

Integrate Twelve Data in just a few minutes using our SDKs and spreadsheet add-ins.

Global coverage

Stock markets as is

Access to all stock exchanges in the world, with a single API - sharing the same format for all data.

Basic

All US market data. Trial symbols for international exchanges.

United States

Real-time

Grow

All US market data + exchanges from Canada, India, Europe, Turkey, and Brazil.

Belgium

EOD delay

Brazil

EOD delay

Canada

France

EOD delay

Germany

EOD delay

India

EOD delay

Ireland

EOD delay

Netherlands

EOD delay

Portugal

EOD delay

Sri Lanka

EOD delay

Turkey

EOD delay

United Kingdom

Pro

All from the Grow plan + most of international exchanges

Argentina

EOD delay

Australia

20 min delay

Austria

EOD delay

Chile

EOD delay

China

EOD delay

Czech Republic

EOD delay

Denmark

EOD delay

Egypt

EOD delay

Germany

EOD delay

Greece

EOD delay

Hong Kong

EOD delay

Hungary

EOD delay

Indonesia

EOD delay

Ireland

EOD delay

Israel

EOD delay

Italy

EOD delay

Japan

EOD delay

Luxembourg

EOD delay

Malaysia

EOD delay

Mexico

EOD delay

New Zealand

EOD delay

Pakistan

EOD delay

Peru

EOD delay

Qatar

EOD delay

Russia

EOD delay

Saudi Arabia

EOD delay

Singapore

EOD delay

South Africa

EOD delay

South Korea

EOD delay

Spain

EOD delay

Switzerland

EOD delay

Taiwan

EOD delay

Thailand

EOD delay

United Arab Emirates

Venezuela

EOD delay

Ultra+

All market data from every exchange.

Single platform

Developer-centric

Rapidly integrate our stock market 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.

Sample code & examples
Extensive reference data
Responses with metadata
JSON & CSV formats
Changelog, roadmap & new features voting

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
                
                    

Reference data

Create powerful financial 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

Fundamentals

Financial information for the company: statements, balance sheets, cash flows, earnings, etc.

Explore

Extended hours

Pre/Post market data for US equities from 1min to 30min intervals.

Explore

Institutional grade infrastructure. Designed to scale.

400,000,000+

Requests per day

50,000+

Stocks available

250,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?

Create an account and start integrating stock market data - no commitment or credit cards required. Or, contact us to prepare a custom solution for your business.

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.

API Reference