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 sales

Reliable data

Data sourced and processed from top PRAs, brokers, governments, and reports ensures institutional-grade reliability.

No licensing

There is no need to pay additional fees or obtain a commercial license. Data can be directly used for business and personal needs.

Low Latency

REST API data is updated minutely, while WebSocket API streaming updates prices with up to 170ms latency.

Ease of integration

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.

Gold

Silver

Palladium

Platinum

Copper

Explore all commodities

Visualize any commodity in the portal

Crude Oil Futures

Brent Futures

Ethanol Futures

Natural Gas

Gasoline

Explore all commodities

Visualize any commodity in the portal

Corn Futures

Cocoa Futures

Cotton Futures

Coffee Futures

Wheat Futures

Explore all commodities

Visualize any commodity in the portal

Cheese Futures

Milk Futures

Feeder Cattle Futures

Live Cattle Futures

Lean Hogs Futures

Explore all commodities

Visualize any commodity in the portal

Build faster

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

API docs WebSocket docs

            
                 API
            
            
                 WebSocket
            
        

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)
        {
            using WebClient wc = new WebClient();
            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";
 
    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="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
    {
        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\": \"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";
 
    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\": \"XAU/USD\"}}");
            }
 
            @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": "XAU/USD"}}')
 

 

                            
                    
                    Python
                
                            
                    
                    Go
                
                            
                    
                    C++
                
                            
                    
                    C#
                
                            
                    
                    Java
                
                            
                    
                    R
                
                    

It’s all about commodities data

Easily access a wide range of commodities prices with Twelve Data API.

Basic Reference data

Commodities pairs list, descriptions, and details.

Learn more

Basic Currency conversion

Convert commodities to currencies with a specified amount.

Learn more

Grow Market data

Real-time pricing data and years of historical prices via time series, quote, and other endpoints.

Learn more

Grow Technical indicators

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

Learn more

Curious, but not a developer?

Leverage TwelveData spreadsheets add-ins.
Integrate data into your workflow - without coding.

Google Sheets

Collaborate from anywhere

Excel

Ideal for Microsoft 365 users

Designed
to scale.

70,000,000+

API requests per day

60+

Commodities available

65,000+

Events per second

FAQ

Questions? Answers.

What is Twelve Data Commodities API?

Twelve Data Commodities API provides real-time and historical access to commodities pricing data. It’s designed for developers, businesses, and financial institutions who need reliable, up-to-date information on a wide range of commodities like precious metals, agricultural products, energies, and more, all delivered via a flexible REST API. With seamless integration and low latency, it’s the perfect solution for building financial applications, trading bots, or managing international transactions.

Does the Commodities API provide real-time data?

Yes, Twelve Data Commodities API delivers real-time data directly from trusted market sources. You’ll receive up-to-the-minute pricing on commodities and exchange rates, ensuring your financial applications and trading platforms stay in sync with the latest market movements.

Can I access historical data as well?

Yes, the API provides access to both real-time and historical data. You can query pricing information from the past, allowing you to track trends and make informed decisions based on long-term data analysis.

What is the data source?

Twelve Data API sources its data from trusted market providers and market makers, ensuring high accuracy and reliability. With 99.9% uptime and low-latency response times, you can count on getting the data you need, exactly when you need it.

What types of commodities can I access?

With Twelve Data Commodities API, you can access a broad array of commodities, including:

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.

How much does the API cost?

Twelve Data API offers flexible pricing plans starting at just $29 per month. Whether you’re a developer, a small business, or a large financial institution, you can choose the plan that fits your needs and budget, with access to both real-time and historical data.

Can I test the API before committing to a paid plan?

Yes, you can start with our free tier, which offers limited access to real-time and historical data. It’s the perfect way to test the API and explore its features before upgrading to a paid plan.

How easy is it to integrate the API?

Integration is straightforward with Twelve Data API. It’s built with developers in mind, offering clear documentation, SDKs, and sample code to help you get started quickly. Whether you’re building applications in Python, JavaScript, or PHP, you’ll find integration fast and easy.

What are some common use cases for this API?

Twelve Data API is used across a variety of industries and applications, including:

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.

Does Twelve Data offer customer support for technical questions?

Yes, we offer comprehensive support for all our API users. Whether you need help with integration or have technical questions, our dedicated support team is here to assist you every step of the way.

Are there code libraries available?

Yes, we provide SDKs and code libraries for a range of programming languages, including Python. These libraries simplify integration and make it easier to start using the API in your projects.

Can the data integrate with other platforms or services?

Absolutely. Twelve Data API is designed to integrate seamlessly with other platforms, such as Excel, Google Sheets, and various trading platforms. With flexible endpoints and easy-to-use connectors, you can bring real-time data into the tools you already use.

Can I access other financial data besides commodities?

Yes, Twelve Data provides access to a wide range of financial data beyond commodities, including stocks, ETFs, mutual funds, forex, indices, cryptocurrencies, and more. You can build applications that integrate multiple financial data sources from a single API.

Is the API scalable for enterprises?

Yes, Twelve Data API is built to scale. Whether you’re a small startup or a large enterprise, our API can handle your data needs, offering flexible plans and high request limits to accommodate growth.

How do I get started with Twelve Data API?

Getting started is simple. Just sign up on our website, choose the plan that best suits your needs, and access our detailed documentation. You’ll be able to start integrating and using the API in just a few minutes. If you need help, our support team is always available to assist.

Working with Twelve Data

Twelve Data guides you through every step of your journey in the knowledge center.

Have other questions?

If you have more questions, contact us so we can help.

Commodities

real-time JSON API spot data

Historical and real-time prices and rates REST APIs for precious metals, energies, and more.

Access any commodity

Powerful and easy-to-use APIs

It’s all about commodities data

Curious, but not a developer?

FAQ

Questions? Answers.

Powerful and
easy-to-use APIs