LinkedIn Lead Scoring: Turn Firmographics into an ICP Fit Score (2026)

Every inbound lead list is really a queue, and the only question that matters is the order. Work it top to bottom and you waste your best reps on tiny accounts and tire-kickers. Score it first and you spend their time where it converts. The cheapest, most objective way to set that order — before anyone has clicked a single email — is firmographic fit: how closely the company behind the lead matches the customers you already win.

This post builds a firmographic lead-scoring model from scratch. We will define an ideal customer profile as a plain scoring function, pull the inputs — industry, employee count, size band, headquarters, founded year — with one API call per company, and rank a real list. The whole thing is about eighty lines of Python and costs a fraction of a cent per lead.

The interesting part is what falls out of it. When I scored nine well-known companies against a mid-market ICP on July 2, 2026, the household names — Stripe, Shopify, Databricks — landed in the middle of the pack, while less famous companies topped it. That is not a bug. It is the entire point of scoring: it measures fit, not fame.

Why fit scoring beats working the list top-down

Lead scoring splits into two questions that people constantly conflate. Fit asks: is this the kind of company we sell to? Intent asks: are they ready to buy now? Intent scoring — email opens, pricing-page visits, demo requests — is powerful, but it is behavioral, volatile, and only exists after a lead engages. Fit is available the instant a lead arrives, it is stable, and it is objective.

Firmographics are the backbone of fit. A company's industry, size, and location do not change week to week, and they map directly to the patterns in your closed-won deals. If you win mid-market software companies in North America, then a mid-market software company in North America is a good lead before they have done anything at all. That is why fit scoring is the right first filter: it is the cheapest signal you have, and it tells you where not to spend effort.

Your ICP is a scoring function

An "ideal customer profile" is usually written as a paragraph in a deck. To score with it, you turn that paragraph into arithmetic: a set of dimensions, each worth some points, summing to a total. For a worked example, here is a concrete ICP — a self-serve developer-tools product — expressed as four weighted dimensions:

These weights are illustrative — yours come from your own win data, and the whole model is a dozen lines you will tune. What matters is the shape: the biggest weight on the dimension that best predicts a close, partial credit for "near misses" (a 6,000-person company is not disqualified, just docked), and a total you can threshold into tiers.

The firmographic inputs (one API call)

Every input the model needs comes back from a single call to Serpent's company endpoint. Pass the company slug or LinkedIn URL, get a firmographic object:

GET https://apiserpent.com/api/linkedin/company?slug=hashicorp
Header: X-API-Key: YOUR_API_KEY

{
  "success": true,
  "data": {
    "name": "HashiCorp",
    "industry": "Software Development",
    "employee_count": 2207,
    "company_size": "1,001-5,000 employees",
    "founded_year": 2012,
    "hq": { "city": "San Francisco", "state": "California", "country": "US" }
  }
}

That is the whole input vector for a fit score: one field for each dimension of the ICP. If your leads arrive as raw company names or domains, run the enrichment-and-validation step first so you are scoring clean records — a lead that resolved to the wrong company will score confidently and wrongly.

A transparent scoring model in Python

Here is the complete model. Each dimension is its own small function so the logic is auditable — no black box, no ML you cannot explain to a skeptical sales director. It fetches each company, scores the four dimensions, sums them, and assigns an A/B/C tier.

import time, requests

API_KEY = "YOUR_API_KEY"
BASE = "https://apiserpent.com/api/linkedin/company"
LEADS = ["stripe", "figma", "datadog", "cloudflare", "hashicorp",
         "airtable", "canva", "shopify", "databricks"]

# ICP: a self-serve developer-tools product. Best-fit accounts are
# software/tech companies, mid-market headcount (500-5,000), US-based.

def industry_score(industry):
    i = (industry or "").lower()
    if "software development" in i: return 40
    if "technology" in i or "internet" in i: return 35
    if "security" in i: return 30
    if "design" in i: return 20
    return 10                                   # IT services, consulting, etc.

def size_score(n):
    if n is None: return 8
    if 500 <= n <= 5000: return 30              # mid-market sweet spot
    if 5000 < n <= 12000: return 18
    if 200 <= n < 500: return 15
    if n > 12000: return 8                       # enterprise: long cycle
    return 5                                     # sub-200: too small

def region_score(country):
    if country == "US": return 20
    if country in ("CA", "GB"): return 12
    return 8

def maturity_score(year):
    if year is None: return 4
    if year >= 2008: return 10
    if year >= 2000: return 6
    return 4

def tier(total):
    return "A" if total >= 80 else "B" if total >= 60 else "C"

def score(slug):
    r = requests.get(BASE, headers={"X-API-Key": API_KEY},
                     params={"slug": slug}, timeout=60)
    r.raise_for_status()
    d = r.json().get("data", {})
    hq = d.get("hq") or {}
    total = (industry_score(d.get("industry"))
             + size_score(d.get("employee_count"))
             + region_score(hq.get("country"))
             + maturity_score(d.get("founded_year")))
    return d.get("name"), total, tier(total)

rows = []
for slug in LEADS:
    rows.append(score(slug))
    time.sleep(0.3)

for name, total, t in sorted(rows, key=lambda r: -r[1]):
    print(f"{t}  {total:>3}  {name}")

Everything here is a rule you can defend in a pipeline review. When a rep asks "why is this account a B and not an A?", you can point at a line of code, not shrug at a model. That auditability is worth more than a couple of points of accuracy from something opaque.

Scoring nine real companies

I ran exactly this model against nine companies on July 2, 2026, using live firmographics. Here is the ranked output, with the per-dimension breakdown so you can see how each score is built:

Method: live GET /api/linkedin/company per company on 2026-07-02, scored with the model above. Change one weight and the ranking shifts — which is exactly what tuning to your own ICP does.

Read down that list and the logic of fit scoring becomes obvious:

• The top of the list is unglamorous, and that is correct. HashiCorp and Airtable win because they hit the mid-market sweet spot (2,207 and 927 employees) in the right industry and region. They are exactly who this ICP sells to.
• The famous names sit in the middle. Stripe (15,924 employees), Databricks (15,917), Shopify (29,034), and Canva (17,220) are all excellent companies — and all land in tier B, because at that scale a self-serve devtools motion faces a long, procurement-heavy sales cycle. Their industry score is high; their size score is what drags them down.
• Region quietly matters. Canva and Shopify lose points for being headquartered outside the US (Australia and Canada), which for a US-covering team is a real friction. Same industry as the leaders, lower total.

If you had worked this list alphabetically or by brand recognition, you would have called Canva and Shopify first. The model tells you to call HashiCorp and Airtable first. Over a few hundred leads, that reordering is the entire ROI of scoring.

From scores to routing

A score is only useful if it changes what happens to the lead. Threshold the total into tiers and wire each tier to an action:

This is where firmographic fit pairs naturally with two other signals from the same API. Layer in a headcount-growth trend to catch B-tier accounts that are heating up, and check what roles they are hiring for to see which team to approach. Fit sets the floor; those trends tell you when a B is about to become an A.

Honest limits: fit is not intent

Firmographic scoring is the right first filter, not the whole answer. Keep its edges in view:

• Fit does not mean ready. A perfect-fit account with no intent is still a cold call. Fit tells you who is worth pursuing; it does not tell you when. Pair it with behavioral signals before a rep spends real time.
• Employee count is a proxy. The number is LinkedIn's associated-member figure, which tracks headcount closely for B2B companies but overstates it for big consumer brands. For size banding it is more than good enough; just do not treat it as an audited payroll number.
• Firmographics drift. A company crosses a size threshold, opens a US office, pivots industries. Re-score on a schedule — quarterly is plenty — rather than treating a score as permanent.
• Weights are opinions. The model is only as good as the ICP behind it. Back-test your weights against last year's closed-won and closed-lost deals before you trust the ranking.

Pricing

You pay for one company lookup per lead scored — and because firmographics change slowly, you cache them and only re-score periodically.

The same deposit unlocks the discount across every endpoint, so the headcount and jobs signals you layer on top of fit come from the same balance. See the full pricing page for the other LinkedIn datasets and the SERP APIs.

A note on compliance

Serpent's company endpoint accesses publicly available LinkedIn data only. There is no login, password, cookie, or credential in the flow — you send a public company URL and your Serpent key, and nothing else. That keeps the integration clean, but it does not automatically make every downstream use permitted.

Whether your specific use is allowed depends on LinkedIn's terms, your jurisdiction, and how you store and apply the data. Scoring public company firmographics to prioritize B2B outreach is a common, well-trodden use case, but treat compliance as your own decision rather than something this article waves through. The API only ever touches public data and never authenticates as a user; you remain responsible for lawful use.

FAQ

What is firmographic lead scoring?

Firmographic lead scoring assigns each lead a fit score based on attributes of the company it belongs to — industry, employee count, size band, headquarters location, and company age. It measures how closely an account matches your ideal customer profile (ICP), independent of any behavior. A firmographic score answers "should we care about this account at all?" and is available the moment a lead arrives, before you have any engagement data.

What company data should I score leads on?

The most useful firmographic inputs are industry (does the company operate in a vertical you sell to), employee_count and company_size (is it in your target segment), headquarters location (is it in a territory you cover), and founded_year (a rough maturity signal). Serpent's company endpoint returns all of these in one call, so you can compute a score per lead automatically.

Should I score leads on firmographics or behavior?

Both, and they answer different questions. Firmographic (fit) scoring tells you whether an account is worth pursuing at all; behavioral (intent) scoring tells you whether they are ready to buy now. Fit is available at first touch and is stable; intent is earned over time and is volatile. Best practice is to combine them: a high-fit, high-intent lead is your top priority, while a high-intent but low-fit lead is often a poor use of a rep's time. Firmographics are the cheapest, most objective place to start.

How much does it cost to score leads with the API?

You pay for one company lookup per lead scored. Company data is $3.00 per 1,000 requests on Default, dropping to $0.30/1,000 on Growth (after a $100 deposit) and $0.15/1,000 on Scale (after a $500 deposit). Scoring 10,000 leads is a one-time $30 on Default or $1.50 at Scale, and you can cache firmographics and only re-score on a schedule. It is pay-as-you-go with no subscription.

Do I need a LinkedIn login to score leads on company data?

No. You send a public company URL or slug and your Serpent API key in an X-API-Key header. The company endpoint accesses publicly available LinkedIn data only — there is no LinkedIn login, cookie, or OAuth flow on your side. You remain responsible for using the data lawfully and within LinkedIn's terms.