Commodities
real-time JSON API spot data
Historical and real-time prices and rates REST APIs for precious metals, energies, and more.
Start now Contact salesData sourced and processed from top PRAs, brokers, governments, and reports ensures institutional-grade reliability.
There is no need to pay additional fees or obtain a commercial license. Data can be directly used for business and personal needs.
REST API data is updated minutely, while WebSocket API streaming updates prices with up to 170ms latency.
Seamlessly integrate our API into your platform before you finish a cup of coffee with detailed documentation and code samples.
Access any commodity
Easily access a wide range of commodities prices with Twelve Data API.
Powerful and
easy-to-use APIs
Our JSON API is designed with developers in mind. Rapidly integrate commodities data into your project with modern languages, from Python to Golang. Using Twelve Data's API means less code maintenance and more time to build a great product.
- Simple commodity documentation with samples
- Numerous SDKs
- Institutional-level security with 256-bit SSL encryption
- Lightweight JSON & CSV formats
- Redistribution and commercial usage
- from twelvedata import TDClient
- td = TDClient(apikey="YOUR_API_KEY_HERE")
- ts = td.time_series(
- symbol="XAU/USD",
- 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 := "XAU/USD"
- 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=XAU/USD&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)
- {
- var response = wc.DownloadString("https://api.twelvedata.com/time_series?symbol=XAU/USD&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=XAU/USD&interval=1min&outputsize=12&apikey=YOUR_API_KEY_HERE";
- JSONParser parser = new JSONParser();
- connection.setRequestMethod("GET");
- connection.setRequestProperty("User-Agent", "twelve_java/1.0");
- connection.connect();
- if (connection.getResponseCode() != 200) {
- }
- 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="XAU/USD", 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": "XAU/USD"}}`
- 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\": \"XAU/USD\"" \
- "}" \
- "}";
- 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
- {
- static void Main()
- {
- }
- 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\": \"XAU/USD\"}}");
- }
- 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) {
- send("{\"action\": \"subscribe\", \"params\":{\"symbols\": \"XAU/USD\"}}");
- }
- @Override
- JSONParser parser = new JSONParser();
- try {
- JSONObject json = (JSONObject) parser.parse(message);
- e.printStackTrace();
- }
- }
- @Override
- 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")
- })
- " and reason ", event$reason, "\n", sep = "")
- })
- })
- })
- ws$send('{"action": "subscribe", "params":{"symbols": "XAU/USD"}}')
It’s all about commodities data
Easily access a wide range of commodities prices with Twelve Data API.
Real-time pricing data and years of historical prices via time series, quote, and other endpoints.
Learn moreExtensive collection of indicators, ready to be used for technical analysis of any commodity.
Learn moreCurious, but not a developer?
Leverage TwelveData spreadsheets add-ins.
Integrate data into your workflow - without coding.
to scale.
FAQ
Questions? Answers.
- Precious metals like gold, silver, and platinum.
- Industrial metals such as copper, aluminum, and zinc.
- Energy products such as crude oil and natural gas.
- Agricultural commodities like corn, wheat, and coffee.
- Livestock including cattle and hogs.
- Financial analysts using real-time data for market analysis.
- Developers building commodities trading systems.
- Businesses requiring commodities currency conversion for international transactions.
- Traders making quick, informed decisions based on real-time market data.