Back to blog
7 min read

Account Scoring With Headcount and Hiring Signals

By Kooperativa Engineering

Account Scoring With Headcount and Hiring Signals

Account scoring with workforce data starts by keeping two scores apart: fit, which asks whether a company looks like the customers you already won, and timing, which asks whether something is changing inside it right now. Compute each from calls you can re-run, then test the fit score against closed deals before you let it rank anyone.

Most account scores fail for a plain reason. They blend both questions into one number with weights picked in a meeting. The number ranks accounts, so it looks finished, but nobody can say whether the ranking is any good. This article builds the two scores separately, shows where workforce data helps and where it misleads, and ends with the test that tells you whether to trust the result.

There is a reason to score the account and not one contact. Forrester's State of Business Buying analysis, published in January 2026 from a survey of nearly 18,000 global business buyers, reports that a typical purchase is influenced by 13 internal stakeholders and nine external participants on average, and that the number rises for more expensive or complex purchases. One person's activity says little about a decision spread across that many people. Company-level signals, such as who joined and which leaders arrived, describe the whole group.

Fit moves slowly, timing moves weekly

Fit is a property of the company: its size, its industry, where it is based, and whether it has a leadership layer that can buy. Those fields change over years, so you can recompute fit once a quarter. Timing is a property of the last few weeks: people joining, senior people arriving, and the pace of both. It changes every week and goes stale within a month.

Keeping the two apart gives you a decision that a single score hides. A company with strong fit and quiet timing is worth keeping warm. A company with weak fit and loud timing is a distraction that looks like an opportunity.

Timing is quietTiming is loud
Strong fitTier 2: monitor and nurtureTier 1: act this week
Weak fitIgnoreWatch, do not chase

Learn fit from your own wins

Instead of guessing what an ideal account looks like, read it off the accounts you already won. Pull the company row for each closed-won customer, take the middle value of staff_count, and keep the industries that appear. Company search rows return staff_count, industries, hq_country_code and founded_year, which is enough for a first profile.

A fit profile learned from closed-won accountsjs
function median(values) {
  const v = [...values].sort((a, b) => a - b);
  return v.length ? v[Math.floor(v.length / 2)] : 0;
}

// wonRows: company search rows for your closed-won customers
export function profileOfWins(wonRows, country) {
  const mid = median(wonRows.map((r) => r.staff_count).filter(Boolean));
  return {
    country,
    minStaff: Math.round(mid / 2),
    maxStaff: Math.round(mid * 2),
    industries: new Set(wonRows.flatMap((r) => r.industries || [])),
  };
}

// Fit is the share of criteria a company meets: 0, 1/3, 2/3 or 1
export function fitScore(row, profile) {
  const inBand = row.staff_count >= profile.minStaff && row.staff_count <= profile.maxStaff;
  const inIndustry = (row.industries || []).some((i) => profile.industries.has(i));
  const inCountry = row.hq_country_code === profile.country;
  return (Number(inBand) + Number(inIndustry) + Number(inCountry)) / 3;
}

The band of half to double the median is a starting guess, not a finding. Widen it if your wins span sizes, and add a criterion only when you can show that it separates wins from losses.

Two details matter here. Use staff_count from the company row everywhere, because the size range printed on a person's profile is a separate field and can disagree with it. And build the candidate list with company search, which returns at most 50 rows a page, so walk the pages and merge by company_id.

Timing, normalized for how many people the index holds

Two calls give you the raw material. The headcount by seniority endpoint returns total_indexed and a breakdown across five bands. The hiring signals endpoint returns the people who started their current role inside a window, up to 365 days, and its total is your count of joins. Ask for per_page set to 1 and you get the total without downloading the people.

Raw join counts mislead when you compare companies. The index holds the profiles that exist for each company, and how many people keep a current profile varies by industry and by company. A company with a thin index shows few joins even when it is hiring fast. Dividing joins by total_indexed gives joins per 100 indexed profiles, which puts companies on the same footing. The pace ratio, joins per day over 30 days divided by joins per day over 90, tells you whether things are speeding up.

Timing for one account: joins per 100 indexed, pace and leadership sharejs
const BASE = 'https://kooperativa.io/api/v1';
const headers = { Authorization: 'Bearer ' + process.env.KOOPERATIVA_API_KEY };

async function get(path, params) {
  const url = BASE + path + '?' + new URLSearchParams(params);
  for (let attempt = 0; attempt < 3; attempt++) {
    const res = await fetch(url, { headers });
    if (res.status === 429 || res.status === 503) {
      const wait = Number(res.headers.get('Retry-After') || 5);
      await new Promise((r) => setTimeout(r, wait * 1000));
      continue;
    }
    return res.ok ? res.json() : null; // null is a gap, never a zero
  }
  return null;
}

export async function timingFor(companyId) {
  const [size, d30, d90] = await Promise.all([
    get('/company/headcount-by-seniority', { company_id: companyId }),
    get('/company/hiring-signals', { company_id: companyId, days: 30, per_page: 1 }),
    get('/company/hiring-signals', { company_id: companyId, days: 90, per_page: 1 }),
  ]);
  if (!size || !d30 || !d90 || !size.total_indexed) return null;

  const indexed = size.total_indexed;
  const b = size.breakdown;
  return {
    companyId,
    joinsPer100: (d90.total / indexed) * 100,
    // above 1 means the last 30 days run faster than the 90 day average
    pace: d90.total ? d30.total / 30 / (d90.total / 90) : 0,
    leaderShare: (b['c-level'] + b.vp + b.director) / indexed,
    scoredAt: new Date().toISOString().slice(0, 10),
  };
}

One data hazard to guard against. The filter behind hiring signals means started after this date, with no upper limit, so a profile that lists a role starting in the future matches it. On 21 November 2026 we found a profile in the job changes feed whose current role began in December 2027. A few records like that will not move an account with many joins, but they can create a signal at a small one. Before a senior arrival drives an outreach, open the full record and check that the start month is not in the future.

Leave departures out until you can read them

Departures are the other half of headcount movement. The past employees endpoint lists people who left a company, with month-level end dates on each past position and no total. Some past positions carry no end date, and a company with many leavers needs many pages. If you use it, count only the rows with an end date inside your window, treat the result as a floor, and cap the number of pages you read. For a first version, joins and leadership mix are enough.

Test the fit score before you trust it

A score earns trust by predicting something. Take your closed deals, won and lost, score each company's fit, and compare the win rate across fit bands. If the high-fit band does not win more often than the low-fit band, the profile is wrong, and no weighting of timing will repair it.

Win rate by fit bandjs
// fitScore and profile come from the first sample above
// deals: [{ company_id, won: true | false }]
// rowsById: Map of company_id to company search row
export function winRateByFit(deals, rowsById, profile) {
  const bands = { high: [0, 0], mid: [0, 0], low: [0, 0] }; // [won, total]
  for (const deal of deals) {
    const row = rowsById.get(deal.company_id);
    if (!row) continue;
    const fit = fitScore(row, profile);
    const band = fit >= 0.99 ? 'high' : fit >= 0.6 ? 'mid' : 'low';
    bands[band][1] += 1;
    if (deal.won) bands[band][0] += 1;
  }
  return Object.fromEntries(
    Object.entries(bands).map(([name, [won, total]]) => [name, total ? won / total : null]),
  );
}

Two cautions. Learn the profile on older deals and test it on newer ones, because a profile learned from the same deals it is tested on will always look good. And test fit only. The index holds current figures, not history, so you cannot rebuild what timing looked like on the day an old deal opened. For timing, store a snapshot every week from now on, and after a quarter compare how often Tier 1 accounts became opportunities against the rest.

Run it weekly and keep the date

Score on a schedule, write the score and the scored_at date back to the CRM, and show the age next to the number. A timing score older than a month describes a company that no longer looks that way. Score the accounts on your target list, not the whole market: a few hundred accounts costs a few calls each, and a whole market costs more than the answer is worth.

This approach has no view of behavior. It cannot see a pricing page visit or a research surge, so pair it with intent data if you buy any. It reflects what people updated on their professional profiles, which lags by however long that takes.

Frequently asked questions

How do you build an account scoring model?

Split it into fit and timing. Learn fit from your closed-won accounts, compute timing from recent joins and leadership mix, and test the fit score against won and lost deals before you trust the ranking.

What is account scoring?

Ranking target companies by how likely they are to become customers, using company-level signals instead of the actions of one contact. Lead scoring rates individual people, account scoring rates the company.

How often should account scores be recalculated?

Recompute timing weekly and fit quarterly. Timing signals age within weeks, while size, industry and location change slowly.

Does workforce data replace intent data?

No. Workforce data shows people joining, leaving and changing roles. It does not show what an account is researching or which pages it visits.

Get started

Try Kooperativa

One API key. Person and company enrichment, structured search, and monitors under one flat license.

Keep reading

We use only cookies that are strictly necessary to run this site (staying signed in, and protecting forms from abuse). Our analytics tool doesn't use cookies or collect personal data. See our Privacy Policy for details.