Price Forecasts Dataset

Access quantitative price forecasts for over 28,000 tickers. FinBrain’s time-series models produce daily and monthly predictions with calibrated confidence intervals and directional signals, ready to plug into research pipelines and production systems.

Methodology

FinBrain price forecasts are generated using ARIMA (AutoRegressive Integrated Moving Average) time-series models. ARIMA captures the statistical structure of historical price movements — trends, seasonality, and autocorrelation — and produces out-of-sample forecasts with calibrated confidence intervals.

We previously explored deep learning architectures (including shallow recurrent networks), but found that their tendency to overfit noisy financial time series produced less reliable out-of-sample forecasts than well-calibrated statistical models. ARIMA is a transparent, rigorously studied methodology with decades of academic validation in financial forecasting.

Key properties:

• Produces point estimates (mid) with lower and upper bounds representing confidence intervals
• Calibrated on rolling historical windows to reflect current market conditions
• Updated daily for all covered tickers before market open
• Directional signals (expectedShortTerm, expectedMidTerm, expectedLongTerm) derived from the forecast path

Forecasts are probabilistic estimates based on historical patterns. They are not guarantees of future performance and should be used alongside other data and analysis.

What’s Included

The Price Forecasts dataset provides:

• Price Forecasts: Predicted price (mid) with lower and upper bounds for each future date
• Expected Moves: Short, mid, and long-term expected percentage changes
• Bound Changes: Lower and upper bound percentage changes
• Daily & Monthly Types: Choose your forecast horizon

Coverage

Price forecasts are generated daily for every ticker in every covered market. Total coverage is approximately 28,000+ tickers across 20 global markets.

United States

Market	Tickers
NYSE	6,000+
NASDAQ	5,500+
ETFs	750+
S&P 500	500+
OTC Market	300+
DOW 30	30

International Equities

Market	Region	Tickers
Canada TSX	Americas	2,500+
Brazil BOVESPA	Americas	2,000+
Mexico BMV	Americas	600+
Hong Kong Hang Seng	Asia-Pacific	3,500+
Australia ASX	Asia-Pacific	2,000+
Russia MOEX	Europe	350+
UK FTSE 100	Europe	100
Germany DAX	Europe	30
Israel TASE	Middle East	850+
Saudi Arabia TASI	Middle East	350+

Global

Market	Tickers
Foreign Exchange	900+
Index Futures	750+
Commodities	150+
Cryptocurrencies	120+

All forecasts update daily before market open. The dataset is delivered point-in-time — each request returns the most recent forward-looking forecast. Historical forecasts are not exposed via the API; users who require a forecast archive should persist the daily output as part of their pipeline.

Understanding Forecasts

Expected Move Fields

Field	Daily Forecasts	Monthly Forecasts
metadata.expectedShortTerm	3-day expected % move	3-month expected % move
metadata.expectedMidTerm	5-day expected % move	6-month expected % move
metadata.expectedLongTerm	10-day expected % move	12-month expected % move

Forecast Objects

Each forecast in the predictions array contains structured fields:

{
  "date": "2024-11-04",
  "mid": 201.33,
  "lower": 197.21,
  "upper": 205.45
}

• mid: Predicted price
• lower: Lower bound of the confidence interval
• upper: Upper bound of the confidence interval

All numeric values are returned as numbers (not strings).

Quick Start

Python SDK

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

df = fb.predictions.ticker("AAPL", prediction_type="daily",
                           as_dataframe=True)
print(df)
#                   mid    lower    upper
# date
# 2024-11-04     201.33   197.21   205.45

Python (requests)

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.finbrain.tech/v2"
headers = {"Authorization": f"Bearer {API_KEY}"}

# Get daily price forecasts for AAPL
response = requests.get(f"{BASE_URL}/predictions/daily/AAPL", headers=headers)
result = response.json()

predictions = result["data"]["predictions"]
for p in predictions:
    print(f"{p['date']}: mid={p['mid']}, lower={p['lower']}, upper={p['upper']}")

For complete code examples in Python, JavaScript, C++, Rust, and cURL, see the API Reference for Price Forecasts API.

Visualization

Plot price forecasts with the built-in SDK chart:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# One-line interactive chart with confidence bands
fb.plot.predictions("AAPL")

AAPL price forecasts with confidence bounds

Use Cases

Systematic Trading Signals

Build trading systems that generate buy/sell signals based on forecast expectations:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def get_trading_signal(symbol, threshold=1.0):
    """Check if a ticker has a strong expected move"""
    result = fb.predictions.ticker(symbol, prediction_type="daily")
    expected = result["metadata"]["expectedShortTerm"]  # 3-day expected move

    if expected > threshold:
        return "bullish", expected
    elif expected < -threshold:
        return "bearish", expected
    else:
        return "neutral", expected

# Screen a watchlist
watchlist = ["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA"]
for symbol in watchlist:
    try:
        signal, expected = get_trading_signal(symbol)
        if signal != "neutral":
            print(f"{symbol}: {signal} ({expected:+.2f}%)")
    except Exception:
        continue

Portfolio Screening

Filter your investment universe based on expected price movements:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def screen_portfolio(symbols, min_expected=0.5):
    """Screen portfolio for positive expected moves"""
    opportunities = []

    for symbol in symbols:
        try:
            result = fb.predictions.ticker(symbol, prediction_type="daily")
            metadata = result["metadata"]
            expected_3day = metadata["expectedShortTerm"]

            if expected_3day > min_expected:
                opportunities.append({
                    "symbol": symbol,
                    "expected_3day": expected_3day,
                    "expected_5day": metadata["expectedMidTerm"],
                    "expected_10day": metadata["expectedLongTerm"]
                })
        except Exception:
            continue

    return sorted(opportunities, key=lambda x: x["expected_3day"], reverse=True)

# Screen tech stocks
watchlist = ["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA"]
opportunities = screen_portfolio(watchlist)

for opp in opportunities:
    print(f"{opp['symbol']}: {opp['expected_3day']:.2f}% (3-day), {opp['expected_5day']:.2f}% (5-day)")

Multi-Horizon Analysis

Compare short, mid, and long-term expectations to identify momentum:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def analyze_momentum(symbol):
    """Analyze if momentum is accelerating or decelerating"""
    result = fb.predictions.ticker(symbol, prediction_type="daily")
    metadata = result["metadata"]
    short = metadata["expectedShortTerm"]    # 3-day
    mid = metadata["expectedMidTerm"]        # 5-day
    long_term = metadata["expectedLongTerm"] # 10-day

    # Check if expectations are increasing across time horizons
    if short > 0 and mid > short and long_term > mid:
        return "accelerating_bullish"
    elif short < 0 and mid < short and long_term < mid:
        return "accelerating_bearish"
    elif short > 0 and mid > 0 and long_term > 0:
        return "bullish"
    elif short < 0 and mid < 0 and long_term < 0:
        return "bearish"
    else:
        return "mixed"

momentum = analyze_momentum("AAPL")
print(f"AAPL momentum: {momentum}")

Related Resources

• Price Forecasts API Reference - Single ticker endpoint
• News Sentiment - Combine with sentiment data