Stock Screener API

Screener endpoints let you fetch data across multiple tickers in a single request. Filter by market or region to narrow results. Instead of querying tickers one by one, use the screener to scan entire markets for sentiment shifts, insider trades, congressional activity, and more.

Authentication

Supports multiple authentication methods (in order of preference):

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`

Endpoints

Endpoint	Description	Requires market/region?
`GET /v2/screener/sentiment`	Screen sentiment across tickers	Yes (market OR region)
`GET /v2/screener/analyst-ratings`	Screen analyst ratings	No (optional)
`GET /v2/screener/insider-trading`	Screen insider trades	No
`GET /v2/screener/congress/house`	Screen House trades	No
`GET /v2/screener/congress/senate`	Screen Senate trades	No
`GET /v2/screener/news`	Screen news articles	No (optional)
`GET /v2/screener/put-call-ratio`	Screen put/call ratios	No (optional)
`GET /v2/screener/linkedin`	Screen LinkedIn data	Yes (market OR region)
`GET /v2/screener/app-ratings`	Screen app ratings	Yes (market OR region)
`GET /v2/screener/predictions/daily`	Screen daily predictions	No (optional)
`GET /v2/screener/predictions/monthly`	Screen monthly predictions	No (optional)

Common Query Parameters

Parameter	Type	Required	Description
`apiKey`	string	No	Your API key (if not using header auth)
`limit`	integer	No	Number of results to return (1-20,000)
`market`	string	No	Filter by market name (e.g., `NASDAQ`, `S&P 500`)
`region`	string	No	Filter by region code (e.g., `US`, `UK`)

Request Examples

Sentiment Screener

from finbrain import FinBrainClient

fb = FinBrainClient(api_key="YOUR_API_KEY")

# Screen predictions by market
df = fb.screener.predictions_daily(market="S&P 500",
                                   as_dataframe=True)
print(df)

# Screen insider trading (no market filter needed)
df = fb.screener.insider_trading(as_dataframe=True)
print(df)

# Screen sentiment for a specific market
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/screener/sentiment?market=NASDAQ&limit=10"

# Screen sentiment by region
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/screener/sentiment?region=US&limit=50"

import requests

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

# Screen sentiment for a specific market
response = requests.get(
    "https://api.finbrain.tech/v2/screener/sentiment",
    headers=headers,
    params={"market": "NASDAQ", "limit": 10}
)
result = response.json()

for ticker in result["data"]["data"]:
    print(f"{ticker['symbol']}: {ticker['score']:.3f}")

# Screen sentiment by region
response = requests.get(
    "https://api.finbrain.tech/v2/screener/sentiment",
    headers=headers,
    params={"region": "US", "limit": 50}
)
result = response.json()
print(f"Average score: {result['data']['summary']['averageScore']:.3f}")

#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 screen_sentiment(const std::string& market, int limit, const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        char* encoded_market = curl_easy_escape(curl, market.c_str(), 0);
        std::string url = "https://api.finbrain.tech/v2/screener/sentiment?market="
            + std::string(encoded_market) + "&limit=" + std::to_string(limit);
        curl_free(encoded_market);

        struct curl_slist* headers = nullptr;
        std::string auth_header = "Authorization: Bearer " + api_key;
        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 = screen_sentiment("NASDAQ", 10, "YOUR_API_KEY");

    for (auto& ticker : result["data"]["data"]) {
        std::cout << ticker["symbol"].get<std::string>() << ": "
                  << ticker["score"].get<double>() << std::endl;
    }

    auto summary = result["data"]["summary"];
    std::cout << "Average: " << summary["averageScore"].get<double>() << std::endl;

    return 0;
}

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

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

#[derive(Debug, Deserialize)]
struct ScreenerData {
    data: Vec<SentimentEntry>,
    summary: SentimentSummary,
}

#[derive(Debug, Deserialize)]
struct SentimentEntry {
    symbol: String,
    name: String,
    date: String,
    score: f64,
}

#[derive(Debug, Deserialize)]
struct SentimentSummary {
    #[serde(rename = "totalTickers")]
    total_tickers: i64,
    #[serde(rename = "averageScore")]
    average_score: f64,
    #[serde(rename = "bullishCount")]
    bullish_count: i64,
    #[serde(rename = "bearishCount")]
    bearish_count: i64,
    #[serde(rename = "neutralCount")]
    neutral_count: i64,
}

fn screen_sentiment(market: &str, limit: i32, api_key: &str)
    -> Result<ScreenerResponse, Box<dyn Error>> {
    let encoded_market = urlencoding::encode(market);
    let url = format!(
        "https://api.finbrain.tech/v2/screener/sentiment?market={}&limit={}",
        encoded_market, limit
    );

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

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let result = screen_sentiment("NASDAQ", 10, "YOUR_API_KEY")?;

    for entry in &result.data.data {
        println!("{}: {:.3}", entry.symbol, entry.score);
    }

    println!("Average: {:.3}", result.data.summary.average_score);

    Ok(())
}

const response = await fetch(
  "https://api.finbrain.tech/v2/screener/sentiment?market=NASDAQ&limit=10",
  {
    headers: { "Authorization": "Bearer YOUR_API_KEY" }
  }
);
const result = await response.json();

for (const ticker of result.data.data) {
  console.log(`${ticker.symbol}: ${ticker.score}`);
}

console.log(`Average: ${result.data.summary.averageScore}`);

Insider Trading Screener

# Screen all recent insider trades
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/screener/insider-trading?limit=20"

# Filter insider trades by market
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.finbrain.tech/v2/screener/insider-trading?market=NASDAQ&limit=50"

import requests

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

# Screen all recent insider trades
response = requests.get(
    "https://api.finbrain.tech/v2/screener/insider-trading",
    headers=headers,
    params={"limit": 20}
)
result = response.json()

for trade in result["data"]["data"]:
    print(f"{trade['symbol']} - {trade['insider']}: "
          f"{trade['transactionType']} {trade['shares']} shares "
          f"(${trade['totalValue']:,.0f})")

summary = result["data"]["summary"]
print(f"\nTotal: {summary['totalTransactions']} transactions "
      f"({summary['buyCount']} buys, {summary['sellCount']} sells)")

#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 screen_insider_trading(int limit, const std::string& api_key) {
    CURL* curl = curl_easy_init();
    std::string response;

    if (curl) {
        std::string url = "https://api.finbrain.tech/v2/screener/insider-trading?limit="
            + std::to_string(limit);

        struct curl_slist* headers = nullptr;
        std::string auth_header = "Authorization: Bearer " + api_key;
        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 = screen_insider_trading(20, "YOUR_API_KEY");

    for (auto& trade : result["data"]["data"]) {
        std::cout << trade["symbol"].get<std::string>() << " - "
                  << trade["insider"].get<std::string>() << ": "
                  << trade["transactionType"].get<std::string>() << " "
                  << trade["shares"].get<int>() << " shares" << std::endl;
    }

    return 0;
}

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

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

#[derive(Debug, Deserialize)]
struct InsiderScreenerData {
    data: Vec<InsiderTradeEntry>,
    summary: InsiderSummary,
}

#[derive(Debug, Deserialize)]
struct InsiderTradeEntry {
    symbol: String,
    name: String,
    date: String,
    insider: String,
    relationship: String,
    #[serde(rename = "transactionType")]
    transaction_type: String,
    shares: i64,
    #[serde(rename = "totalValue")]
    total_value: i64,
}

#[derive(Debug, Deserialize)]
struct InsiderSummary {
    #[serde(rename = "totalTransactions")]
    total_transactions: i64,
    #[serde(rename = "totalTickers")]
    total_tickers: i64,
    #[serde(rename = "buyCount")]
    buy_count: i64,
    #[serde(rename = "sellCount")]
    sell_count: i64,
}

fn screen_insider_trading(limit: i32, api_key: &str)
    -> Result<InsiderScreenerResponse, Box<dyn Error>> {
    let url = format!(
        "https://api.finbrain.tech/v2/screener/insider-trading?limit={}",
        limit
    );

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

    Ok(response)
}

fn main() -> Result<(), Box<dyn Error>> {
    let result = screen_insider_trading(20, "YOUR_API_KEY")?;

    for trade in &result.data.data {
        println!("{} - {}: {} {} shares (${:.0})",
            trade.symbol, trade.insider, trade.transaction_type,
            trade.shares, trade.total_value);
    }

    println!("Total: {} transactions ({} buys, {} sells)",
        result.data.summary.total_transactions,
        result.data.summary.buy_count,
        result.data.summary.sell_count);

    Ok(())
}

const response = await fetch(
  "https://api.finbrain.tech/v2/screener/insider-trading?limit=20",
  {
    headers: { "Authorization": "Bearer YOUR_API_KEY" }
  }
);
const result = await response.json();

for (const trade of result.data.data) {
  console.log(`${trade.symbol} - ${trade.insider}: ${trade.transactionType} ${trade.shares} shares ($${trade.totalValue.toLocaleString()})`);
}

const { totalTransactions, buyCount, sellCount } = result.data.summary;
console.log(`Total: ${totalTransactions} transactions (${buyCount} buys, ${sellCount} sells)`);

Responses

Sentiment Screener Response (200 OK)

{
  "success": true,
  "data": {
    "data": [
      { "symbol": "VIV", "name": "Telefonica Brasil SA ADR", "date": "2026-01-19", "score": 0.644 },
      { "symbol": "POWL", "name": "Powell Industries Inc", "date": "2026-01-19", "score": 0.406 }
    ],
    "summary": {
      "totalTickers": 2,
      "averageScore": 0.525,
      "bullishCount": 2,
      "bearishCount": 0,
      "neutralCount": 0
    }
  },
  "meta": { "timestamp": "2026-01-19T15:23:10.900Z" }
}

Sentiment Screener Fields

Field	Type	Description
`data[].symbol`	string	Stock ticker symbol
`data[].name`	string	Company name
`data[].date`	string	Date of the sentiment score (YYYY-MM-DD)
`data[].score`	number	Sentiment score from -1 (bearish) to 1 (bullish)
`summary.totalTickers`	integer	Number of tickers in the result
`summary.averageScore`	number	Average sentiment score across all tickers
`summary.bullishCount`	integer	Number of tickers with positive sentiment
`summary.bearishCount`	integer	Number of tickers with negative sentiment
`summary.neutralCount`	integer	Number of tickers with neutral sentiment

Insider Trading Screener Response (200 OK)

{
  "success": true,
  "data": {
    "data": [
      {
        "symbol": "NVDA",
        "name": "Nvidia Corporation",
        "date": "2026-01-15",
        "insider": "Jensen Huang",
        "relationship": "CEO",
        "transactionType": "Sale",
        "shares": 120000,
        "totalValue": 15600000
      }
    ],
    "summary": {
      "totalTransactions": 1,
      "totalTickers": 1,
      "buyCount": 0,
      "sellCount": 1
    }
  },
  "meta": { "timestamp": "2026-01-19T15:23:12.000Z" }
}

Insider Trading Screener Fields

Field	Type	Description
`data[].symbol`	string	Stock ticker symbol
`data[].name`	string	Company name
`data[].date`	string	Transaction date (YYYY-MM-DD)
`data[].insider`	string	Insider name
`data[].relationship`	string	Insider’s role or relationship to the company
`data[].transactionType`	string	Type of transaction (e.g., Sale, Buy)
`data[].shares`	integer	Number of shares traded
`data[].totalValue`	integer	Total transaction value in USD
`summary.totalTransactions`	integer	Total number of transactions returned
`summary.totalTickers`	integer	Number of unique tickers in the result
`summary.buyCount`	integer	Number of buy transactions
`summary.sellCount`	integer	Number of sell transactions

Usage Examples

Find Most Bullish Tickers

import requests

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

response = requests.get(
    "https://api.finbrain.tech/v2/screener/sentiment",
    headers=headers,
    params={"market": "NASDAQ", "limit": 100}
)
result = response.json()

# Sort by sentiment score descending
tickers = sorted(result["data"]["data"], key=lambda x: x["score"], reverse=True)

print("Top 10 most bullish NASDAQ tickers:")
for t in tickers[:10]:
    print(f"  {t['symbol']:>6} ({t['name'][:30]:30}): {t['score']:.3f}")

Track Large Insider Purchases

import requests

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

response = requests.get(
    "https://api.finbrain.tech/v2/screener/insider-trading",
    headers=headers,
    params={"limit": 500}
)
result = response.json()

# Filter for large purchases only
large_buys = [
    t for t in result["data"]["data"]
    if t["transactionType"] == "Buy" and t["totalValue"] >= 1_000_000
]

print(f"Large insider purchases (above $1M):")
for trade in large_buys:
    print(f"  {trade['symbol']:>6} - {trade['insider']}: "
          f"${trade['totalValue']:>12,.0f} ({trade['shares']:,} shares)")

Screen Congressional Trading Activity

import requests

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

# Screen House trades
house = requests.get(
    "https://api.finbrain.tech/v2/screener/congress/house",
    headers=headers,
    params={"limit": 100}
).json()

# Screen Senate trades
senate = requests.get(
    "https://api.finbrain.tech/v2/screener/congress/senate",
    headers=headers,
    params={"limit": 100}
).json()

print(f"Recent House trades: {len(house['data']['data'])}")
print(f"Recent Senate trades: {len(senate['data']['data'])}")

Errors

Code	Error	Description
400	Bad Request	Invalid parameters or missing required market/region
401	Unauthorized	Invalid or missing API key
404	Not Found	Endpoint not found
500	Internal Server Error	Server-side error

Sentiments API - Get sentiment for a single ticker
Insider Transactions API - Get insider trades for a single ticker
House Trades API - Get House trades for a single ticker
Analyst Ratings API - Get analyst ratings for a single ticker
Recent Data API - Get the most recent data entries across all tickers