AI Price Forecasts Dataset

Access deep learning-powered price predictions for over 10,000 tickers. FinBrain’s AI models analyze historical price data and alternative signals to generate daily and monthly forecasts with directional signals.

What’s Included

The AI Price Forecasts dataset provides:

Price Forecasts: Predicted price with lower and upper bounds for each future date
Expected Moves: Short, mid, and long-term expected percentage changes
Sentiment Score: Current market sentiment (-1 to 1)
Daily & Monthly Types: Choose your prediction horizon

Coverage

Market	Tickers	Update Frequency
S&P 500	500+	Daily
NASDAQ	3,000+	Daily
NYSE	2,500+	Daily
Crypto	100+	Daily
Total	10,000+	Daily

Understanding Predictions

Expected Move Fields

Field	Daily Predictions	Monthly Predictions
`expectedShort`	3-day expected % move	3-month expected % move
`expectedMid`	5-day expected % move	6-month expected % move
`expectedLong`	10-day expected % move	12-month expected % move

Date-Keyed Forecasts

Each date key contains: "predicted_price,lower_bound,upper_bound"

Example: "2024-11-04": "201.33,197.21,205.45" means:

Predicted price: $201.33
Lower bound: $197.21
Upper bound: $205.45

Note: All numeric values are returned as strings - convert with float() for calculations.

Quick Start

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Get price forecasts as DataFrame
df = fb.predictions.ticker("AAPL", prediction_type="daily", as_dataframe=True)
print(df)

For complete code examples in Python, JavaScript, C++, Rust, and cURL, see the API Reference for Ticker Predictions and Market Predictions.

Use Cases

Systematic Trading Signals

Build trading systems that generate buy/sell signals based on AI predictions:

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

def get_trading_signals(market, threshold=1.0):
    """Screen market for tickers with strong expected moves"""
    predictions = fb.predictions.market(market, prediction_type="daily")

    bullish = []
    bearish = []

    for item in predictions:
        ticker = item["ticker"]
        expected = float(item["prediction"]["expectedShort"])  # 3-day expected move

        if expected > threshold:
            bullish.append((ticker, expected))
        elif expected < -threshold:
            bearish.append((ticker, expected))

    return bullish, bearish

bullish, bearish = get_trading_signals("S&P 500")
print(f"Bullish signals ({len(bullish)}): {[t[0] for t in bullish[:10]]}")
print(f"Bearish signals ({len(bearish)}): {[t[0] for t in bearish[:10]]}")

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(tickers, min_expected=0.5):
    """Screen portfolio for positive expected moves"""
    opportunities = []

    for ticker in tickers:
        try:
            data = fb.predictions.ticker(ticker, prediction_type="daily")
            pred = data["prediction"]
            expected_3day = float(pred["expectedShort"])

            if expected_3day > min_expected:
                opportunities.append({
                    "ticker": ticker,
                    "expected_3day": expected_3day,
                    "expected_5day": float(pred["expectedMid"]),
                    "expected_10day": float(pred["expectedLong"])
                })
        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['ticker']}: {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(ticker):
    """Analyze if momentum is accelerating or decelerating"""
    data = fb.predictions.ticker(ticker, prediction_type="daily")
    pred = data["prediction"]

    short = float(pred["expectedShort"])   # 3-day
    mid = float(pred["expectedMid"])       # 5-day
    long_term = float(pred["expectedLong"]) # 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}")

Ticker Predictions API Reference - Single ticker endpoint
Market Predictions API Reference - Market-wide endpoint
News Sentiment - Combine with sentiment data
Python SDK Documentation