Available Tickers API

Retrieve a list of all tickers that have predictions available. Use query parameters to filter by prediction type, market, or region.

Endpoint

GET /v2/tickers

Authentication

Authenticate using one of the following methods (in order of recommendation):

Method	Example
Bearer token (recommended)	Authorization: Bearer YOUR_API_KEY
X-API-Key header	X-API-Key: YOUR_API_KEY
Query parameter	?apiKey=YOUR_API_KEY
Legacy query parameter	?token=YOUR_API_KEY

Parameters

Query Parameters

Parameter	Type	Required	Description
type	string	No	Prediction type: daily or monthly
market	string	No	Filter by market name (e.g., S&P 500, NASDAQ)
region	string	No	Filter by region (e.g., US, Global)
limit	integer	No	Limit the number of results returned

Request

Python SDK

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Get daily prediction tickers
df = fb.available.tickers("daily", market="S&P 500",
                          as_dataframe=True)
print(df)

cURL

# Get all tickers with daily predictions
curl "https://api.finbrain.tech/v2/tickers?type=daily" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Filter by market
curl "https://api.finbrain.tech/v2/tickers?type=daily&market=S%26P%20500" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Filter by region with a limit
curl "https://api.finbrain.tech/v2/tickers?region=US&limit=10" \
  -H "Authorization: Bearer YOUR_API_KEY"

Python (requests)

import requests

headers = {"Authorization": "Bearer YOUR_API_KEY"}

# Get tickers with daily predictions
response = requests.get(
    "https://api.finbrain.tech/v2/tickers",
    headers=headers,
    params={"type": "daily"}
)
data = response.json()
print(f"Daily predictions available for {len(data['data']['tickers'])} tickers")

# Filter by market
response = requests.get(
    "https://api.finbrain.tech/v2/tickers",
    headers=headers,
    params={"type": "daily", "market": "S&P 500"}
)
sp500 = response.json()
for t in sp500["data"]["tickers"][:5]:
    print(f"  {t['symbol']} - {t['name']}")

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_tickers(const std::string& api_key,
                           const std::string& type = "daily",
                           const std::string& market = "") {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        std::string url = "https://api.finbrain.tech/v2/tickers?type=" + type;

        if (!market.empty()) {
            char* encoded_market = curl_easy_escape(curl, market.c_str(), 0);
            url += "&market=" + std::string(encoded_market);
            curl_free(encoded_market);
        }

        std::string auth_header = "Authorization: Bearer " + api_key;
        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, auth_header.c_str());

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

    return json::parse(response);
}

int main() {
    auto result = get_available_tickers("YOUR_API_KEY", "daily", "S&P 500");

    auto& tickers = result["data"]["tickers"];
    std::cout << "Found " << tickers.size() << " tickers" << std::endl;

    // Print first 10 tickers
    for (size_t i = 0; i < std::min(size_t(10), tickers.size()); i++) {
        std::cout << "  " << tickers[i]["symbol"].get<std::string>()
                  << " - " << tickers[i]["name"].get<std::string>() << std::endl;
    }

    return 0;
}

Rust

use reqwest::blocking::Client;
use reqwest::header::{AUTHORIZATION, HeaderValue};
use serde::Deserialize;
use std::error::Error;

#[derive(Debug, Deserialize)]
struct TickerInfo {
    symbol: String,
    name: String,
}

#[derive(Debug, Deserialize)]
struct TickersData {
    tickers: Vec<TickerInfo>,
}

#[derive(Debug, Deserialize)]
struct TickersResponse {
    success: bool,
    data: TickersData,
}

fn get_available_tickers(
    api_key: &str,
    pred_type: &str,
    market: Option<&str>,
) -> Result<TickersResponse, Box<dyn Error>> {
    let mut url = format!(
        "https://api.finbrain.tech/v2/tickers?type={}",
        pred_type
    );

    if let Some(m) = market {
        url.push_str(&format!("&market={}", urlencoding::encode(m)));
    }

    let client = Client::new();
    let response: TickersResponse = client
        .get(&url)
        .header(AUTHORIZATION, HeaderValue::from_str(&format!("Bearer {}", api_key))?)
        .send()?
        .json()?;

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let data = get_available_tickers("YOUR_API_KEY", "daily", Some("S&P 500"))?;

    println!("Found {} tickers", data.data.tickers.len());

    // Print first 10 tickers
    for ticker_info in data.data.tickers.iter().take(10) {
        println!("  {} - {}", ticker_info.symbol, ticker_info.name);
    }

    Ok(())
}

JavaScript

// Get daily tickers
const response = await fetch(
  "https://api.finbrain.tech/v2/tickers?type=daily",
  { headers: { "Authorization": "Bearer YOUR_API_KEY" } }
);
const result = await response.json();
console.log(`Found ${result.data.tickers.length} tickers`);
console.log(result.data.tickers[0]); // { symbol: "AAPL", name: "Apple Inc." }

// Filter by market
const sp500 = await fetch(
  "https://api.finbrain.tech/v2/tickers?type=daily&market=" + encodeURIComponent("S&P 500"),
  { headers: { "Authorization": "Bearer YOUR_API_KEY" } }
);
const sp500Data = await sp500.json();
console.log(`S&P 500 tickers: ${sp500Data.data.tickers.length}`);

Response

Success Response (200 OK)

{
  "success": true,
  "data": {
    "tickers": [
      { "symbol": "AAPL", "name": "Apple Inc." },
      { "symbol": "MSFT", "name": "Microsoft Corp." },
      { "symbol": "GOOGL", "name": "Alphabet Inc." }
    ]
  },
  "meta": { "timestamp": "2026-01-19T15:05:55.187Z" }
}

Response Fields

Field	Type	Description
success	boolean	Whether the request was successful
data	object	Response data wrapper
data.tickers	array	List of ticker objects
data.tickers[].symbol	string	Ticker symbol
data.tickers[].name	string	Company or asset name
meta	object	Response metadata
meta.timestamp	string	ISO 8601 timestamp of the response

Prediction Types

Type	Description	Forecast Horizon
daily	Daily price predictions	10 trading days
monthly	Monthly price predictions	12 months

Usage Examples

Check Ticker Availability

import requests

headers = {"Authorization": "Bearer YOUR_API_KEY"}

def is_ticker_available(ticker, pred_type="daily"):
    """Check if a ticker has predictions available"""
    response = requests.get(
        "https://api.finbrain.tech/v2/tickers",
        headers=headers,
        params={"type": pred_type}
    )
    tickers = response.json()["data"]["tickers"]
    symbols = [t["symbol"] for t in tickers]
    return ticker.upper() in symbols

# Check if AAPL has daily predictions
if is_ticker_available("AAPL", "daily"):
    print("AAPL has daily predictions available")
else:
    print("AAPL does not have predictions")

Build Ticker Universe

import requests

headers = {"Authorization": "Bearer YOUR_API_KEY"}

# Get S&P 500 tickers directly via query parameter
response = requests.get(
    "https://api.finbrain.tech/v2/tickers",
    headers=headers,
    params={"type": "daily", "market": "S&P 500"}
)
sp500_tickers = response.json()["data"]["tickers"]
print(f"S&P 500 tickers: {len(sp500_tickers)}")

# Filter for specific tickers from results
tech_symbols = {"AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META"}
tech_tickers = [t for t in sp500_tickers if t["symbol"] in tech_symbols]
print(f"Tech universe: {[t['symbol'] for t in tech_tickers]}")

Cross-Reference with Watchlist

import requests

headers = {"Authorization": "Bearer YOUR_API_KEY"}

watchlist = ["AAPL", "MSFT", "XYZ123", "GOOGL", "INVALID"]

# Get available tickers
response = requests.get(
    "https://api.finbrain.tech/v2/tickers",
    headers=headers,
    params={"type": "daily"}
)
tickers_data = response.json()["data"]["tickers"]
available = set(t["symbol"] for t in tickers_data)

# Find which watchlist items are available
valid = [t for t in watchlist if t in available]
invalid = [t for t in watchlist if t not in available]

print(f"Valid tickers: {valid}")
print(f"Invalid tickers: {invalid}")

Errors

Code	Error	Description
400	Bad Request	Invalid prediction type or query parameters
401	Unauthorized	Invalid or missing API key
403	Forbidden	Authenticated, but not authorized to access this resource
429	Too Many Requests	Rate limit exceeded — wait and retry
500	Internal Server Error	Server-side error

Related Endpoints

• Available Markets - Get available markets
• Ticker Predictions - Get predictions for a ticker
• Market Predictions - Get predictions for a market