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/lobbying`	Screen corporate lobbying filings	No
`GET /v2/screener/government-contracts`	Screen government contract awards	No
`GET /v2/screener/reddit-mentions`	Screen Reddit mentions	No (optional)
`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"] == "Purchase" 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'])}")

Corporate Lobbying Screener Response (200 OK)

{
  "success": true,
  "data": {
    "data": [
      {
        "company": "AAPL",
        "companyName": "Apple Inc.",
        "date": "2025-09-15",
        "registrantName": "Fierce Government Relations",
        "income": 150000,
        "expenses": 0,
        "quarter": "Q3"
      }
    ],
    "summary": {
      "totalFilings": 1,
      "totalCompanies": 1,
      "totalSpend": 150000
    }
  },
  "meta": { "timestamp": "2026-03-12T12:00:00.000Z" }
}

Corporate Lobbying Screener Fields

Field	Type	Description
`data[].company`	string	Stock ticker symbol
`data[].companyName`	string	Company name
`data[].date`	string	Filing date (YYYY-MM-DD)
`data[].registrantName`	string	Lobbying firm name
`data[].income`	number	Income reported (USD)
`data[].expenses`	number	Expenses reported (USD)
`data[].quarter`	string	Filing quarter (Q1-Q4)
`summary.totalFilings`	integer	Total number of filings returned
`summary.totalCompanies`	integer	Number of unique companies
`summary.totalSpend`	number	Sum of income + expenses across all filings

Government Contracts Screener Response (200 OK)

{
  "success": true,
  "data": {
    "data": [
      {
        "symbol": "LMT",
        "name": "Lockheed Martin Corporation",
        "awardId": "CONT_AWD_0001",
        "awardAmount": 50000000,
        "recipientName": "Lockheed Martin Corporation",
        "startDate": "2025-06-01",
        "awardingAgency": "Department of Defense",
        "naicsDescription": "Aircraft Manufacturing"
      }
    ],
    "summary": {
      "totalContracts": 150,
      "totalTickers": 45,
      "totalValue": 2500000000
    }
  },
  "meta": { "timestamp": "2026-03-17T15:05:59.853Z" }
}

Government Contracts Screener Fields

Field	Type	Description
`data[].symbol`	string	Stock ticker symbol
`data[].name`	string	Company name
`data[].awardId`	string	Unique contract award identifier
`data[].awardAmount`	number	Total award value in USD
`data[].recipientName`	string	Company receiving the contract
`data[].startDate`	string	Contract start date (YYYY-MM-DD)
`data[].awardingAgency`	string	Federal agency issuing the contract
`data[].naicsDescription`	string	NAICS industry description
`summary.totalContracts`	integer	Total number of contracts returned
`summary.totalTickers`	integer	Number of unique tickers
`summary.totalValue`	number	Sum of all award amounts (USD)

Reddit Mentions Screener Response (200 OK)

{
  "success": true,
  "data": {
    "data": [
      {
        "symbol": "TSLA",
        "name": "Tesla, Inc.",
        "date": "2026-03-16T14:00:00.000Z",
        "totalMentions": 57,
        "subreddits": {
          "wallstreetbets": 45,
          "stocks": 12
        }
      }
    ],
    "summary": {
      "totalEntries": 1,
      "totalTickers": 1,
      "averageMentions": 57,
      "topMentioned": ["TSLA"],
      "subredditNames": ["stocks", "wallstreetbets"]
    }
  },
  "meta": { "timestamp": "2026-03-17T15:05:59.853Z" }
}

Reddit Mentions Screener Fields

Field	Type	Description
`data[].symbol`	string	Stock ticker symbol
`data[].name`	string	Company name
`data[].date`	string	Snapshot timestamp (ISO 8601)
`data[].totalMentions`	integer	Total mentions across all subreddits
`data[].subreddits`	object	Mention counts keyed by subreddit name
`summary.totalEntries`	integer	Total entries returned
`summary.totalTickers`	integer	Unique tickers in result
`summary.averageMentions`	number	Average mentions per entry
`summary.topMentioned`	array	Top tickers by mention count
`summary.subredditNames`	array	List of subreddit names in data

Errors

Code	Error	Description
400	Bad Request	Invalid parameters or missing required market/region
401	Unauthorized	Invalid or missing API key
403	Forbidden	Authenticated, but not authorized to access this resource
404	Not Found	Endpoint not found
429	Too Many Requests	Rate limit exceeded — wait and retry
500	Internal Server Error	Server-side error

News Sentiment API - Get sentiment for a single ticker
Insider Transactions API - Get insider trades for a single ticker
Congressional Trading API - Get House and Senate trades for a single ticker
Analyst Ratings API - Get analyst ratings for a single ticker
Government Contracts API - Get government contracts for a single ticker
Reddit Mentions API - Get Reddit mentions for a single ticker
Recent Data API - Get the most recent data entries across all tickers