Data That Moves Before the Market Does

Research-grade data with full history, normalized and ticker-mapped across every dataset. Deep historical granularity for backtesting and model training, production-clean for live systems.

Congressional Trades

US House and Senate member trading activity. Disclosure-based signals from STOCK Act filings.

Corporate Lobbying

Federal lobbying disclosures. Track corporate influence and regulatory exposure.

Government Contracts

Federal contract awards and modifications. Revenue signals from government spending.

Coming Soon

Patent Filings

Track patent applications and grants by ticker. Early signals of innovation and R&D activity.

News Sentiment

AI-powered sentiment scores from financial news. Gauge market mood and momentum.

LinkedIn Metrics

Track employee counts and follower growth. Early indicators of company trajectory.

App Store Ratings

Mobile app performance data from iOS and Android stores. User sentiment signals.

Reddit Mentions

Track ticker mentions across Reddit communities like WallStreetBets and r/stocks.

Price Forecasts

Daily and monthly price forecasts with confidence intervals from time-series models.

Analyst Ratings

Track analyst upgrades, downgrades, and price target changes from major institutions.

Put/Call Ratios

Options market sentiment data. Monitor put/call ratios and options flow signals.

Insider Transactions

Real-time SEC Form 4 filings. Track executive purchases, sales, and option exercises.

28,000+

Tickers Covered

20

Global Markets

12

Datasets

70+

Countries Served

99.9%

API Uptime

From Data to Insights
FinBrain Terminal

All FinBrain datasets through an intuitive visual interface. No code required.

Real-Time Dashboard

Market command center with geopolitical monitor, AI signals, earnings calendar, treasury yields, and prediction markets — everything you need in one view.

Geopolitical Intelligence

Interactive globe with global conflict and event data. Defense and OSINT analysis feeds. Futures positioning across all asset classes.

Ticker Deep Dive

Every dataset for any ticker — price forecasts with confidence intervals, sentiment charts, insider transactions, analyst ratings, lobbying filings, and Reddit activity.

Commodities & Energy

Crude oil inventories, natural gas storage, US production data, and futures positioning across energy, metals, and agriculture.

15 Alternative Data Screeners

Filter 28,000+ tickers by price forecasts, insider buying, congressional trades, lobbying, government contracts, Reddit mentions, and more.

Transaction-Level Analysis

Drill down to individual filings — analyze every insider purchase, congressional trade, lobbying disclosure, and government contract by transaction value, date, and entity.

Crypto Markets

Top coins by market cap, sentiment index, Bitcoin network stats, trending coins, and institutional futures positioning.

Open Terminal Terminal Docs

Straight to Your Pipeline
via REST API & SDKs

One integration for your engineering team. Build trading systems, research platforms, and client-facing applications in days.

Deploy in Hours, Not Months

A single REST API with full historical data and consistent schema across all datasets. One integration covers everything — no vendor patchwork, no missing history.

Unified schema, all datasets - Consistent endpoint structure eliminates per-vendor integration work
Python SDK - pip install finbrain-python for rapid prototyping and production use
High-throughput access - Built for backtesting, live trading, and platform integrations
Full data history - Years of granular historical data for backtesting, model training, and research

Get Started Python SDK Docs

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Get price forecasts
predictions = fb.predictions.ticker("AAPL",
    as_dataframe=True)

# Get insider trading data
insider = fb.insider_transactions.ticker("AAPL",
    as_dataframe=True)

# Get news sentiment
sentiment = fb.sentiments.ticker("NVDA",
    as_dataframe=True)

# Get price forecasts
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/predictions/daily/AAPL"

# Get insider transactions
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/insider-trading/AAPL"

# Get sentiment data
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/sentiment/NVDA"

const headers = { "Authorization": "Bearer YOUR_API_KEY" };
const BASE = "https://api.finbrain.tech/v2";

const predictions = await fetch(
  `${BASE}/predictions/daily/AAPL`, { headers }
).then(res => res.json());

const insider = await fetch(
  `${BASE}/insider-trading/AAPL`, { headers }
).then(res => res.json());

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

json get_predictions(const std::string& symbol,
                     const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response, url =
      "https://api.finbrain.tech/v2/predictions/daily/" + symbol;
    std::string auth = "Authorization: Bearer " + api_key;
    struct curl_slist* hdrs = curl_slist_append(nullptr, auth.c_str());

    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hdrs);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
    curl_easy_perform(curl);
    curl_slist_free_all(hdrs);
    curl_easy_cleanup(curl);
    return json::parse(response);
}

use reqwest::blocking::Client;
use reqwest::header::{AUTHORIZATION, HeaderValue};

fn get_predictions(symbol: &str, api_key: &str)
    -> Result<serde_json::Value, reqwest::Error> {
    let url = format!(
        "https://api.finbrain.tech/v2/predictions/daily/{}",
        symbol
    );
    Client::new().get(&url)
        .header(AUTHORIZATION, HeaderValue::from_str(
            &format!("Bearer {}", api_key)).unwrap())
        .send()?.json()
}

Plug Alternative Data
Into Your LLMs

Give your team's AI assistants direct access to FinBrain data. Accelerate research workflows across the organization.

AI-Native Data Access

Use the Model Context Protocol (MCP) to connect FinBrain data to Claude, ChatGPT, and custom LLM applications. Multiply analyst productivity.

Natural language queries - Analysts query predictions, insider trades, and sentiment in plain English
Claude Desktop integration - Just pip install finbrain-mcp and add your config
Custom LLM apps - Build internal research copilots and client-facing AI tools
Real-time data - Always current market intelligence across your team’s AI workflows

Get Started MCP Docs

”Compare price forecasts for our portfolio holdings"

"Show insider trades for AAPL in the last 30 days"

"How has sentiment shifted across our S&P 500 coverage?"

"Flag congressional trades that overlap with our positions”

Full Platform Access

From self-serve plans to custom enterprise agreements. Scale as your team grows.

Monthly Annual Save 17%

$99 /month

All 12 alternative datasets
28,000+ tickers across 20 markets
15 alternative data screeners
Real-time Dashboard & macro indicators
Geopolitical monitoring & OSINT feeds
Yield curves, COT positioning & more
Portfolio tracking & analytics
Email support

Get Started

$499 /month

Everything in FinBrain Terminal
Full data history
Full REST API access
2,000 API requests/hour
Python SDK included
MCP for LLM integration
Custom integrations
Priority support

Get Started

For Teams

Custom

Everything in Terminal + API + MCP
Dedicated account manager
Data redistribution license
Client-facing display rights
AI/LLM training rights
SLA guarantees
On-premise deployment options
White-label solutions

Book a Demo

Frequently Asked Questions

Common questions about integration, coverage, and enterprise plans.

Getting Started

Questions about API access and setup.

Data & Coverage

What data is available and how often it updates.

Pricing & Support

Subscription plans and support options.

How do I get started?

Sign up at terminal.finbrain.tech for instant access. Most users are in production within a day. Enterprise clients can contact sales for guided onboarding.

What programming languages are supported?

We provide an official Python SDK with pip install finbrain-python. For other languages, use our REST API directly with any HTTP client.

What are the rate limits?

Individual plans include 2,000 requests per hour. Enterprise plans offer custom rate limits to match your team's throughput requirements.

Can we redistribute or display the data to clients?

Redistribution and client-facing display rights are available with our Enterprise plan. Contact sales to discuss licensing for your use case.

What markets are covered?

We cover 20 global markets including US equities (S&P 500, NASDAQ, NYSE), international stocks, forex, crypto, and commodities. Over 28,000 tickers with daily predictions.

How often is the data updated?

Price forecasts update daily before market open. Insider transactions and congressional trades update in real-time as filings are published. Sentiment scores update throughout the trading day.

How far back does historical data go?

Historical data varies by dataset. Price forecasts have 5+ years of history for backtesting. Insider and congressional data goes back to when disclosure requirements began.

How should we evaluate the price forecasts?

Our forecasts are generated using ARIMA time-series models that capture the statistical properties of historical price movements and produce out-of-sample predictions with calibrated confidence intervals. Full historical data is available for independent backtesting. See the Price Forecasts dataset page for methodology details.

What plans are available for teams?

FinBrain Terminal at $99/month and Terminal + API + MCP at $499/month for individual users. Enterprise plans offer custom pricing with SLAs, dedicated support, and custom rate limits for teams and institutions.

What support is available?

All plans include email support. Terminal + API plans include priority support. Enterprise clients get a dedicated account manager and SLA-backed response times.

What does the Enterprise plan include?

Data redistribution rights, client-facing display rights, AI/LLM training rights, dedicated account management, SLA guarantees, on-premise deployment options, and white-label solutions. Enterprise plans are tailored to your team's specific requirements.

Can we start with an individual plan and upgrade later?

Yes. Many teams start with an individual Terminal + API plan for evaluation, then upgrade to Enterprise as they scale. Your data and integrations carry over seamlessly.

Alternative Data for Systematic Edge