Skip to content
  • datasets
  • linkedin data

LinkedIn Metrics Dataset

Access LinkedIn employee counts and follower metrics as alternative data signals. Track workforce growth and company popularity trends that may precede stock price movements.

What’s Included

Section titled “What’s Included”

The LinkedIn Metrics dataset provides:

  • Employee Count: Current number of employees on LinkedIn
  • Employee Growth: Month-over-month and year-over-year changes
  • Follower Count: Company page followers
  • Follower Growth: Trending popularity metrics
  • Historical Data: Track workforce trends over time
  • Weekly Updates: Fresh data every week

Coverage

Section titled “Coverage”
CoverageDetails
MarketsS&P 500, NASDAQ, NYSE
MetricsEmployees, followers, growth rates
Update FrequencyWeekly
Historical Data2+ years

Quick Start

Section titled “Quick Start”
from finbrain import FinBrainClient


fb = FinBrainClient(api_key="YOUR_API_KEY")


# Get LinkedIn data as DataFrame
df = fb.linkedin_data.ticker("S&P 500", "META", as_dataframe=True)
print(df.head())

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

Interpreting LinkedIn Metrics

Section titled “Interpreting LinkedIn Metrics”

Employee Growth Signals

Section titled “Employee Growth Signals”
YoY GrowthInterpretationSignal
> 20%Rapid expansionStrong growth phase
10% - 20%Healthy growthPositive outlook
0% - 10%Moderate growthStable operations
-10% - 0%Slight contractionCaution
< -10%Significant layoffsPotential distress

Follower Growth Signals

Section titled “Follower Growth Signals”
MoM GrowthInterpretation
> 3%Viral growth / major news
1% - 3%Above average interest
0% - 1%Normal growth
< 0%Declining interest

Use Cases

Section titled “Use Cases”

Workforce Trend Scanner

Section titled “Workforce Trend Scanner”

Scan for companies with significant workforce changes:

from finbrain import FinBrainClient


fb = FinBrainClient(api_key="YOUR_API_KEY")


def scan_workforce_changes(tickers):
    """Find companies with significant workforce changes"""
    results = []


    for ticker in tickers:
        try:
            data = fb.linkedin_data.ticker("S&P 500", ticker)


            if not data.get("linkedinData") or len(data["linkedinData"]) < 30:
                continue


            # Compare current to 30 days ago
            latest = data["linkedinData"][0]
            older = data["linkedinData"][29]


            change = ((latest["employeeCount"] - older["employeeCount"]) / older["employeeCount"]) * 100


            results.append({
                "ticker": ticker,
                "employees": latest["employeeCount"],
                "change_30d": change
            })
        except Exception:
            continue


    # Sort by change
    return sorted(results, key=lambda x: x["change_30d"], reverse=True)


tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA", "NFLX"]
changes = scan_workforce_changes(tickers)


print("Workforce Changes (30-day):")
for c in changes:
    trend = "hiring" if c["change_30d"] > 0 else "declining"
    print(f"  {c['ticker']}: {c['employees']:,} employees ({c['change_30d']:+.1f}% - {trend})")

Growth Momentum Indicator

Section titled “Growth Momentum Indicator”

Create a composite growth score:

from finbrain import FinBrainClient


fb = FinBrainClient(api_key="YOUR_API_KEY")


def calculate_growth_momentum(market, ticker):
    """Calculate growth momentum from LinkedIn data"""
    data = fb.linkedin_data.ticker(market, ticker)


    if not data.get("linkedinData") or len(data["linkedinData"]) < 7:
        return None


    latest = data["linkedinData"][0]
    week_ago = data["linkedinData"][6]


    # Calculate weekly growth rates
    emp_growth = ((latest["employeeCount"] - week_ago["employeeCount"]) / week_ago["employeeCount"]) * 100
    fol_growth = ((latest["followersCount"] - week_ago["followersCount"]) / week_ago["followersCount"]) * 100


    # Weighted composite score
    momentum = emp_growth * 0.6 + fol_growth * 0.4


    return {
        "ticker": ticker,
        "momentum_score": momentum,
        "employee_growth": emp_growth,
        "follower_growth": fol_growth,
        "signal": "bullish" if momentum > 1 else "bearish" if momentum < -1 else "neutral"
    }


momentum = calculate_growth_momentum("S&P 500", "NVDA")
print(f"{momentum['ticker']}: {momentum['signal']} (Score: {momentum['momentum_score']:.2f})")

Tech Sector Comparison

Section titled “Tech Sector Comparison”

Compare workforce trends across tech sector:

from finbrain import FinBrainClient


fb = FinBrainClient(api_key="YOUR_API_KEY")


def compare_tech_workforce():
    """Compare workforce metrics across major tech companies"""
    tech_tickers = {
        "AAPL": "Apple",
        "MSFT": "Microsoft",
        "GOOGL": "Alphabet",
        "AMZN": "Amazon",
        "META": "Meta",
        "NVDA": "NVIDIA",
        "TSLA": "Tesla"
    }


    results = []


    for ticker, name in tech_tickers.items():
        try:
            data = fb.linkedin_data.ticker("S&P 500", ticker)


            if not data.get("linkedinData"):
                continue


            latest = data["linkedinData"][0]
            results.append({
                "company": name,
                "ticker": ticker,
                "employees": latest["employeeCount"],
                "followers": latest["followersCount"]
            })
        except Exception:
            continue


    # Sort by employee count
    return sorted(results, key=lambda x: x["employees"], reverse=True)


comparison = compare_tech_workforce()
print("Tech Workforce Comparison:")
print("-" * 60)
for c in comparison:
    print(f"{c['company']:12} | {c['employees']:>10,} employees | {c['followers']:>12,} followers")

Detect Hiring Acceleration

Section titled “Detect Hiring Acceleration”

Find companies that are accelerating hiring:

from finbrain import FinBrainClient


fb = FinBrainClient(api_key="YOUR_API_KEY")


def detect_hiring_acceleration(market, ticker, lookback_days=30):
    """Detect if a company is accelerating hiring"""
    data = fb.linkedin_data.ticker(market, ticker)


    if not data.get("linkedinData") or len(data["linkedinData"]) < lookback_days:
        return None


    linkedin_data = data["linkedinData"]


    # Calculate growth rate for recent period vs older period
    recent_start = linkedin_data[0]["employeeCount"]
    recent_end = linkedin_data[lookback_days//2 - 1]["employeeCount"]
    older_start = linkedin_data[lookback_days//2]["employeeCount"]
    older_end = linkedin_data[lookback_days - 1]["employeeCount"]


    recent_growth = ((recent_start - recent_end) / recent_end) * 100
    older_growth = ((older_start - older_end) / older_end) * 100


    acceleration = recent_growth - older_growth


    return {
        "ticker": ticker,
        "recent_growth": recent_growth,
        "older_growth": older_growth,
        "acceleration": acceleration,
        "signal": "accelerating" if acceleration > 0.5 else "decelerating" if acceleration < -0.5 else "stable"
    }


result = detect_hiring_acceleration("S&P 500", "NVDA")
print(f"Hiring trend: {result['signal']} (Acceleration: {result['acceleration']:.2f}%)")
Section titled “Related Resources”