#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";
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";
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"}}')
As an expert in the field of financial data retrieval and processing using various programming languages, libraries, and APIs, I have hands-on experience with multiple technologies involved in fetching and parsing real-time stock data. My expertise spans languages such as C++, C#, Java, Python, and R, as well as the usage of popular libraries like cJSON, libcurl, WebSocketPP, WebSocket4Net, RcppSimdJson, and TwelveData.
Let's break down the key concepts used in the provided code snippets:
-
C++ (libcurl, cJSON):
- The code uses libcurl for making HTTP requests to the Twelve Data API.
- The cJSON library is employed for parsing and manipulating JSON data received from the API.
- The program fetches real-time stock data for TSLA, extracts metadata, and prints the symbol and closing price.
-
C# (.NET, System.Net, System.Text.Json):
- The code uses the WebClient class from System.Net to download JSON data from the Twelve Data API.
- It utilizes System.Text.Json for deserializing the JSON response into C# objects, making it easier to work with the data.
-
Java (HttpURLConnection, org.json.simple):
- The code establishes an HTTP connection using HttpURLConnection to retrieve JSON data from the Twelve Data API.
- It uses the org.json.simple library for parsing and processing the JSON response.
-
R (RcppSimdJson):
- RcppSimdJson is used for fetching and parsing JSON data in R.
- The code requests real-time stock data for AAPL, and RcppSimdJson is employed for loading and processing the JSON response.
-
Python (twelvedata, WebSocket):
- The code demonstrates the usage of the TwelveData Python library for fetching real-time stock data through WebSocket.
- It subscribes to the TSLA symbol and prints events received from the WebSocket connection.
-
C++ (WebSocketPP, cJSON):
- WebSocketPP is utilized for establishing a WebSocket connection to Twelve Data's real-time quotes endpoint.
- The code subscribes to the TSLA symbol and processes events received via WebSocket, including handling subscribe status and price change events.
-
C# (.NET, WebSocket4Net):
- WebSocket4Net is used to create a WebSocket client for connecting to Twelve Data's WebSocket endpoint.
- The program subscribes to the TSLA symbol and handles events such as open, close, error, and message reception.
-
Java (java_websocket, org.json.simple):
- The code establishes a WebSocket connection to Twelve Data's real-time quotes endpoint using the java_websocket library.
- It subscribes to the TSLA symbol and processes received JSON messages.
-
R (websocket):
- The
websocketR library is employed for creating a WebSocket client. - The code establishes a WebSocket connection to the Twelve Data quotes endpoint, subscribes to TSLA, and handles open, close, error, and message events.
- The
These snippets collectively showcase how to fetch real-time stock data using different programming languages, HTTP requests, and WebSocket connections while leveraging various libraries and APIs for JSON processing and data manipulation.
