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

package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
)
const apiKey = "YOUR_API_KEY_HERE"
type TimeSeriesResponse struct {
Status string `json:"status"`
Message string `json:"message"`
Meta struct {
Symbol string `json:"symbol"`
Interval string `json:"interval"`
} `json:"meta"`
Data []struct {
Datetime string `json:"datetime"`
Open string `json:"open"`
High string `json:"high"`
Low string `json:"low"`
Close string `json:"close"`
Volume string `json:"volume"`
} `json:"values"`
}
func main() {
symbol := "AAPL"
interval := "1min"
url := fmt.Sprintf("https://api.twelvedata.com/time_series?symbol=%s&interval=%s&apikey=%s", symbol, interval, apiKey)
resp, err := http.Get(url)
if err != nil {
log.Fatal(err)
} defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
var response TimeSeriesResponse
if err := json.Unmarshal(body, response); err != nil {
log.Fatal(err)
}
if response.Status != "ok" {
log.Fatalf("Error: %s\n", response.Message)
}
fmt.Printf("Time Series for symbol: %s\n", response.Meta.Symbol)
for, data := range response.Data {
fmt.Printf("Time: %s, Open: %s, High: %s, Low: %s, Close: %s, Volume: %s\n", data.Datetime, data.Open, data.High, data.Low, data.Close, data.Volume)
}
}

#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=AAPL&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=AAPL&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=AAPL&interval=1min&outputsize=12&apikey=YOUR_API_KEY_HERE";
URL requestURL = new URL(REQUEST_URL);
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="AAPL", on_event=on_event)
ws.connect()
ws.keep_alive()

package main
import (
"fmt"
"log"
"github.com/gorilla/websocket"
)
const websocketURL = "wss://ws.twelvedata.com/v1/quotes/price?apikey=YOUR_API_KEY_HERE"
func main() {
conn, _, err := websocket.DefaultDialer.Dial(websocketURL, nil)
if err != nil {
log.Fatal("connect to WebSocket failed:", err)
}
defer conn.Close()
subscribeMessage := `{"action": "subscribe", "params": {"symbols": "AAPL"}}`
err = conn.WriteMessage(websocket.TextMessage, []byte(subscribeMessage))
if err != nil {
log.Fatal("message send failed:", err)
}
for {
_, message, err := conn.ReadMessage()
if err != nil {
log.Fatal("message read failed:", err)
}
fmt.Printf("Received: %s\n", message)
}
}

#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\": \"AAPL\"" \
"}" \
"}";
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\": \"AAPL\"}}");
}
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";
WebSocketClient client = new WebSocketClient(new URI(ENDPOINT)) {
@Override
public void onOpen(ServerHandshake handshake) {
System.out.println("TDWebSocket opened!");
send("{\"action\": \"subscribe\", \"params\":{\"symbols\": \"AAPL\"}}");
}
@Override
public void onMessage(String message) {
JSONParser parser = new JSONParser();
try {
JSONObject json = (JSONObject) parser.parse(message);
System.out.println(json);
e.printStackTrace();
}
}
@Override
public void onClose(int status, String reason, boolean remote) {
System.out.println("TDWebSocket closed.");
this.close();
}
@Override
e.printStackTrace();
}
};
client.connectBlocking();
}
}

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