Available Markets API

Retrieve a list of all markets supported by the FinBrain API. Use this endpoint to discover available markets before querying for specific tickers.

Endpoint

GET /v1/available/markets

Authentication

Requires API key via token query parameter.

Parameters

Parameter	Type	Required	Description
token	string	Yes	Your API key

Request

cURL

curl "https://api.finbrain.tech/v1/available/markets?token=YOUR_API_KEY"

Python SDK

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")
markets = fb.available.markets()
print(markets)

C++

#include <iostream>
#include <string>
#include <curl/curl.h>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* userp) {
    userp->append((char*)contents, size * nmemb);
    return size * nmemb;
}

json get_available_markets(const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        std::string url = "https://api.finbrain.tech/v1/available/markets?token=" + api_key;

        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_perform(curl);
        curl_easy_cleanup(curl);
    }

    return json::parse(response);
}

int main() {
    auto data = get_available_markets("YOUR_API_KEY");

    std::cout << "Available markets:" << std::endl;
    for (auto& market : data["availableMarkets"]) {
        std::cout << "  - " << market.get<std::string>() << std::endl;
    }

    return 0;
}

Rust

use reqwest::blocking::Client;
use serde::Deserialize;
use std::error::Error;

#[derive(Debug, Deserialize)]
struct MarketsResponse {
    #[serde(rename = "availableMarkets")]
    available_markets: Vec<String>,
}

fn get_available_markets(api_key: &str) -> Result<MarketsResponse, Box<dyn Error>> {
    let url = format!(
        "https://api.finbrain.tech/v1/available/markets?token={}",
        api_key
    );

    let client = Client::new();
    let response: MarketsResponse = client.get(&url).send()?.json()?;

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let data = get_available_markets("YOUR_API_KEY")?;

    println!("Available markets:");
    for market in &data.available_markets {
        println!("  - {}", market);
    }

    Ok(())
}

Python (requests)

import requests

response = requests.get(
    "https://api.finbrain.tech/v1/available/markets",
    params={"token": "YOUR_API_KEY"}
)
markets = response.json()
print(markets)

JavaScript

const response = await fetch(
  "https://api.finbrain.tech/v1/available/markets?token=YOUR_API_KEY"
);
const markets = await response.json();
console.log(markets);

Response

Success Response (200 OK)

{
  "availableMarkets": [
    "DOW 30",
    "S&P 500",
    "NASDAQ",
    "NYSE",
    "ETFs",
    "UK FTSE 100",
    "Germany DAX",
    "Canada TSX",
    "Australia ASX",
    "HK Hang Seng",
    "Mexico BMV",
    "Foreign Exchange",
    "Commodities",
    "Crypto Currencies",
    "Index Futures",
    "Tadawul TASI",
    "Russia MOEX",
    "Brazil BOVESPA",
    "Tel Aviv TASE",
    "OTC Market"
  ]
}

Response Fields

Field	Type	Description
availableMarkets	array	List of available market identifiers

Available Markets

Market ID	Market Name	Region
DOW30	DOW 30	US
SP500	S&P 500	US
NASDAQ	NASDAQ	US
NYSE	NYSE	US
ETFs	ETFs	US
FTSE100	UK FTSE 100	UK
DAX	Germany DAX	Germany
TSX	Canada TSX	Canada
ASX	Australia ASX	Australia
HangSeng	HK Hang Seng	Hong Kong
BMV	Mexico BMV	Mexico
Currencies	Foreign Exchange	Global
Commodities	Commodities	Global
Cryptocurrencies	Crypto Currencies	Global
Futures	Index Futures	Global
TASI	Tadawul TASI	Saudi Arabia
MOEX	Russia MOEX	Russia
BOVESPA	Brazil BOVESPA	Brazil
TASE	Tel Aviv TASE	Israel
OTC	OTC Market	US

Usage Example

Use the markets endpoint to dynamically build a market selector:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Get available markets
markets = fb.available.markets()

# Build market selector
print("Available Markets:")
for i, market in enumerate(markets["availableMarkets"], 1):
    print(f"  {i}. {market}")

# Get tickers for selected market
selected_market = markets["availableMarkets"][0]  # S&P 500
tickers = fb.available.tickers(prediction_type="daily")
print(f"\n{selected_market} has {len(tickers)} tickers with predictions")

Errors

Code	Error	Description
401	Unauthorized	Invalid or missing API key
500	Internal Server Error	Server-side error

Related Endpoints

• Available Tickers - Get tickers for a market
• Market Predictions - Get predictions for a market