Hiring Signals: An API Workflow for Timing Outreach

A company posting three new sales roles is telling you something. They’ve got budget, they’re growing that team, and someone senior just got approval to spend.

Job postings are the most public buying signal there is. They’re deliberately published, they’re timestamped, and almost nobody in sales is watching them systematically.

So here’s how to watch them with an API instead of refreshing careers pages like it’s 2011. Code included, failure modes included, and one story about the time I pitched a company on a role they’d filled six weeks earlier.

What are hiring signals?

Hiring signals are changes in a company’s job postings (new roles, hiring surges, first-ever positions) used as evidence of growth, budget, and upcoming purchases.

The key word is evidence. Most sales intelligence is inference: someone visited a page, someone’s “intent score” ticked up, trust us. A job posting is different. The company wrote it, approved it, and published it on purpose, with a date attached.

And postings don’t just say “we’re hiring.” Read properly, they say what a company is building, which team got budget, and roughly when the spending starts. That’s a lot of intelligence to leave sitting on a careers page.

📌 Definition: A hiring signal = a change in a company's job postings that tells you a team is growing, a budget exists, and a problem is being staffed. Public, timestamped, and deliberate.

Why job postings are the most honest buying signal

Because posting a job costs real money, and companies don’t spend real money to decorate.

Every published role is a budget commitment before the first interview happens:

“The average cost per hire was nearly $4,700, [but] many employers estimate the total cost to hire a new employee can be three to four times the position’s salary.”

Source: SHRM, “The Real Costs of Recruitment”

Nobody commits that kind of money casually. A posting means a manager fought for headcount and won, which means that team’s problems just got officially funded.

This isn’t a fringe idea, either. Economists treat job openings as a leading indicator at national scale: the Bureau of Labor Statistics runs an entire monthly survey (JOLTS) on openings because they move ahead of economic activity. LinkedIn’s Economic Graph does the same with professional data at global scale. Watching one company’s postings for sales timing is the exact same logic, pointed at one account instead of an economy.

And there’s a bonus layer most people never read: the posting BODY. The requirements section of a job ad routinely names the exact tools the team uses (“experience with [CRM], [dialer], [warehouse]”), which is competitive intelligence the company just volunteered. A posting for a role that requires your competitor’s product tells you who to displace and when the team evaluating it is growing. Free technographics, hiding in the qualifications list.

The honest trade-off: hiring signals have weaker coverage than intent data (not every buyer is hiring) but far stronger evidence when they fire. You’ll get fewer alerts and trust each one more. For outbound timing, I’ll take that trade every week.

What each role actually signals

So which role should YOU watch? Different postings mean completely different things, and picking the right one is most of the strategy:

• SDRs / BDRs: they’re scaling outbound. Sales tooling, data providers, and enablement vendors: this is your signal.
• Head of RevOps: they’re about to consolidate and buy tooling. Someone is being hired specifically to make stack decisions.
• First Security Engineer: compliance just became someone’s problem. Security vendors, auditors, and infrastructure tools, take note.
• Head of Partnerships: a channel motion is starting. Integration platforms and co-selling plays become relevant.
• DevOps / SRE surge: infrastructure is hurting. Observability, cloud, and reliability tools have a window.
• First Product Marketing Manager: the go-to-market is maturing past founder-led sales. Content, analytics, and launch tooling follow.

The pattern: pick the role that signals YOUR product is suddenly relevant, not the role that’s most common. “Software Engineer” postings are everywhere and mean almost nothing. “First Head of RevOps” at a Series B company is practically a purchase order with a job title.

And watch for FIRSTS generally. The first hire in any function is a stronger signal than the fifth, because it marks the moment a problem got promoted from “someone’s side task” to “someone’s entire job.”

Seniority tells its own story too. A company hiring a VP before the team exists is building top-down: expect strategy purchases, platform decisions, bigger contracts on slower cycles. A company stacking up individual contributors under an existing manager is scaling bottom-up: expect tooling purchases, per-seat products, faster yeses. Same function, opposite buying motions, and the job titles told you which one you’re walking into before the first call.

The two endpoints

• Jobs API: live postings filtered by title, location, industry, size, funding, and revenue, each one carrying the hiring company’s firmographics
• Career Page Finder: the company’s own job board URL, for when you want to check the source

The firmographics on each posting are what make this useful. You’re not just getting “someone is hiring”; you’re getting who they are, how big, and how funded, in the same response. No second lookup, no joining datasets at midnight.

Two ways to point the telescope

Before the first API call, decide what you’re actually watching. There are two modes, and they answer different questions:

• Account mode: you have a named list (target accounts, open opportunities, dream logos) and you want to know WHEN each one starts hiring for your buyer’s team. Timing is the output. This is the mode most sales teams should start with.
• Discovery mode: you have no list, and the postings ARE the list. Search by role plus firmographic filters (country, industry, size band) and every company that comes back is, by definition, hiring for the thing you care about. Net-new accounts you’d never have found, pre-qualified by their own careers page.

Discovery mode is the underrated one. A traditional prospect list guesses at fit and hopes for timing. A jobs search inverts it: timing is guaranteed (they’re hiring NOW) and the attached firmographics let you filter for fit in the same call.

In practice, mature teams run both: a weekly account-mode pass over the named list for outreach timing, and a monthly discovery pass to top up the pipeline with companies visibly building in their direction. Same endpoint, same code, different filters.

Step 1: Search the postings

from cufinder import Cufinder

client = Cufinder('your-api-key-here')

result = client.cja(
    name='sales development representative',
    country='US',
    industry='software',
    followers_count_min=1000
)
jobs = result['data']['jobs']

Name and country are required: name is the job title, matched as a substring. Everything else narrows it: industry, state, city, employee size band, founding year, funding range, revenue range, follower counts. The same company filters you’d use for list building, applied to who’s hiring.

Each item in jobs comes back as two nested objects:

• job: title, the posting URL, location, and, crucially, posted_at with a human-readable posted_at_text like “4 days ago”. Freshness is a first-class field.
• company: name, industry, website, LinkedIn, follower count, employee range, annual revenue, funding amount, and headquarters location. The full firmographic profile, attached to every posting.

And the cost is friendly for a watcher: per the docs, a jobs search runs 2 credits per search, not per posting returned. A weekly multi-role watchlist is one of the cheapest workflows you can run on the platform, and I say that as someone who watches the credit dashboard professionally.

That’s detection raw material. Now let’s make it mean something.

Step 2: Turn postings into a signal

One posting is noise. Three postings for the same team in a month is a signal.

from collections import Counter

def rank_by_hiring_volume(jobs):
    counts = Counter()
    for j in jobs or []:
        company = (j.get('company') or {}).get('name')
        if company:
            counts[company] += 1
    return counts.most_common()

hot = [(c, n) for c, n in rank_by_hiring_volume(jobs) if n >= 3]

That threshold is doing real work. A company with one open SDR role is backfilling someone who quit. A company with five is building a team, and those are two completely different conversations: one is “sorry for your loss,” the other is “you’re about to need what I sell.”

💡 Rule: One posting is a backfill. Three for the same team in a month is a build-out. Alert on the delta, not the count.

Step 3: Watch for change over time

Like most signals, the value is in the delta: the difference between what you saw last run and this run. So store what you saw and compare:

import json, os
from collections import Counter
from cufinder import Cufinder

client = Cufinder('your-api-key-here')
STATE = 'hiring_state.json'

def load():
    return Counter(json.load(open(STATE))) if os.path.exists(STATE) else Counter()

def run(min_new=2, **filters):
    previous = load()
    result = client.cja(**filters)
    jobs = result['data']['jobs'] or []
    current = Counter()

    for j in jobs:
        company = (j.get('company') or {}).get('name')
        if company:
            current[company] += 1

    alerts = []
    for company, count in current.items():
        delta = count - previous.get(company, 0)
        if delta >= min_new:
            alerts.append({'company': company,
                           'open_roles': count,
                           'new_since_last_run': delta})

    json.dump(dict(current), open(STATE, 'w'))
    return sorted(alerts, key=lambda a: -a['new_since_last_run'])

Run it weekly. Your first run sets the baseline and should alert on nothing, which is expected rather than broken. From run two onward, every alert means hiring VOLUME changed, which filters out the enterprises that always have openings and the evergreen ads that never close.

Weekly also matches how hiring actually moves. Postings don’t turn over daily, and a seven-day gap gives your delta something meaningful to measure instead of counting refresh jitter.

Step 4: Check the source before anyone sends

Before a rep reaches out, confirm the roles are still open. Career Page Finder gives you the company’s own board:

careers = client.ccp('stripe.com')

One call, and you get the careers page URL to eyeball. Thirty seconds of checking beats opening with “I saw you’re hiring SDRs” about a role they filled six weeks ago. I know exactly how that conversation goes, and I’ll show you the receipt later in this article.

Make the check a hard rule in the workflow, not a suggestion. Alert fires → human opens the careers page → THEN the send happens. It’s the cheapest quality gate in outbound.

Reading magnitude: one posting vs a surge

Raw counts lie: enterprises always have 400 openings. Magnitude thinking fixes it. Three different measurements, three different meanings:

• The count (“12 open sales roles”) describes company size and churn more than intent. Useful context, weak trigger.
• The delta (“4 more than last week”) is your workhorse; it’s what the state-file watcher measures, and it works at any company size.
• The spike (“triple the usual pace for this company”) is the strongest version: volume measured against the company’s own baseline, so a startup adding 3 roles rings as loudly as an enterprise adding 30.

The code above gives you deltas. If you’d rather consume the detection ready-made, the Buying Signals docs define a sales-hiring-surge signal (sustained sales-hiring above the company’s own baseline) alongside siblings for engineering hiring surges and jobs-open spikes. Same logic, already computed, with magnitude buckets attached.

Whichever route you take, the principle holds: measure companies against themselves, not against each other. That’s what turns hiring data into hiring signals.

Route the alert, or nothing happens

Here’s the failure I see most after the technical build works: the watcher runs, the alerts pile up in a Slack channel, and nobody owns them. Detection without routing is just well-organized FOMO.

So give every alert three things at birth:

• An owner. Route by territory or account assignment, automatically. An alert addressed to “the team” is addressed to nobody.
• A deadline. Hiring surges are timing signals, and timing decays. A 48-hour SLA from alert to verified send keeps the advantage the workflow exists to create.
• Context, bundled. The rep should open one message and see everything: which roles, the delta, the company’s size and funding, and the careers-page URL for the verification click. Make the right action the lazy action.

That context bundle is why the firmographics-in-the-response design matters so much. Everything the rep needs shipped in the same API payload; your routing code just has to forward it instead of making anyone go look things up.

The other side of the coin: decline signals

Hiring data cuts both ways, and the negative signals are just as actionable, sometimes more.

Watch for the reverse patterns in the same weekly data:

• Postings dropping toward zero at a company that used to hire steadily, often the first public sign of a freeze. For new outbound it means “wrong quarter, park it.” For account managers it’s a churn-risk flare worth escalating.
• A hiring freeze during your deal cycle. If open roles vanish mid-negotiation, budgets are being re-examined. Better to know from the data than from a ghosted follow-up.
• First posting in a new country: the growth mirror image. A company’s first-ever role in a new market usually precedes office openings, local tooling needs, and compliance spending in that region.

The delta watcher you already built detects all of this for free: a strongly negative delta is just as loud as a positive one. Most teams throw the negative half away. Keep it. Knowing when NOT to pitch an account protects reply rates just as surely as knowing when to pounce.

Combine hiring with other signals

That’s where it gets good. A company that raised recently AND is hiring for the team you sell to is a much stronger trigger than either alone.

The logic compounds cleanly: funding says budget exists, hiring says the budget is being deployed on the problem you solve. Pair this watcher with the funding endpoint and require both before an account jumps the queue. I wrote up the other half as its own build, the funding-triggered outreach workflow, and the two share the same state-file pattern, so merging them is straightforward.

raised in the last 90 days AND hiring surge in your buyer's team → top of the outreach queue, today

Keep the AND strict. Two weak signals OR’d together produce twice the noise; two independent signals AND’d together produce a short list your reps will actually believe in.

And sequence the signals when you can. Funding usually fires first, hiring follows a few weeks later as the plans turn into headcount. An account that raised last month and surged hiring this week isn’t just qualified; it’s mid-sprint, and your outreach lands while the growth is actually happening rather than after it’s staffed and settled.

How to reference a posting without being creepy

That’s detection. Now what to do with an alert, because the message is where hiring-signal outreach either shines or face-plants.

The face-plant version opens with surveillance: “I noticed you posted 3 SDR roles on Tuesday.” Technically impressive. Also mildly unsettling, and it makes the email about YOUR tooling instead of their problem.

The version that works opens with the problem the hiring creates:

• “Teams that scale outbound quickly usually hit a data-quality wall around rep number ten. How are you planning around that?”
• “Standing up a RevOps function usually means someone inherits five disconnected tools in week one. Happy to share how two similar teams consolidated.”
• “Growing the sales team this fast usually strains the lead flow. Is pipeline coverage keeping up with the hiring plan?”

Notice none of these say “I saw your job posting.” The hiring signal decided WHO gets the email and WHEN. The problem decides what the email says. Keep those roles separate and the message reads like insight instead of monitoring.

🧠 Rule of thumb: Never open with "I saw you're hiring." Open with the problem the hiring creates; that's the part they haven't heard 40 times this week.

And verify the person before you send. Contact data rots at roughly 22.5% a year per HubSpot’s decay research, and companies in hiring mode rot faster, because that’s literally what hiring is. Look the contact up on send day.

Your first month, week by week

Want to know what realistic looks like? Here’s the honest calendar for a new hiring-signals workflow:

• Week 1: baseline run. Zero alerts, by design. Resist the urge to “fix” it. Use the week to tune your title list and agency filters instead.
• Week 2: first real deltas. Expect a couple of false-ish positives: an evergreen ad that got reposted, a staffing firm that slipped the filter. Tighten and move on.
• Week 3: first verified outreach goes out. A handful of sends, each one career-page-checked, each one problem-first. This is where reply quality tells you whether the role you chose actually maps to your product.
• Week 4: review. Alerts fired, sends made, replies earned. If the role isn’t producing conversations, change the ROLE, not the workflow: the machinery is fine; the hypothesis about what signals relevance is what needs iterating.

A month of this gives you something most outreach programs never get: a tested, written-down link between a public growth behavior and your pipeline. From there it compounds: add a second role, a second region, the funding AND-gate. But earn the first month first.

What breaks

Job titles vary wildly. “SDR”, “Sales Development Representative”, “Business Development Rep” and “Growth Associate” can all be the same job. The name filter is a substring match, which helps, but run several searches and pool the results before counting.

Stale postings. Some companies leave roles up for months, or advertise evergreen positions they never intend to close. Volume changes are more trustworthy than raw counts, which is exactly why the watcher measures deltas.

Ghost jobs. The uglier cousin of stale postings: roles published with no real intent to fill (for pipeline building, morale optics, or market research). It’s a real enough phenomenon to have its own name and documentation. You can’t detect a ghost from the posting alone, but the combination of delta logic (ghosts don’t surge) and the career-page check (ghosts often vanish there first) filters out most of them.

Agencies and staffing firms. They post constantly on behalf of other companies and will dominate your results. Filter them out by industry early, or your “hottest account” will be a recruiter forever.

Big companies always hiring. An enterprise with 400 open roles isn’t sending a signal, that’s just Tuesday. Cap by company size or use the delta rather than the total.

Seasonal noise. Retail hires for Q4. Accounting firms staff up before tax season. Universities post on academic calendars. If your vertical has a rhythm, a “surge” in the usual month is the calendar talking, not the budget. Know the season before you trust the spike.

The quarter we watched RevOps roles

Let me tell you about my favorite quarter of outbound, and the embarrassing week that led to it.

First, the embarrassment. Early 2024, I emailed a promising software company about “scaling your SDR team”, based on a posting I’d seen weeks earlier and never re-checked. The reply was one line: “We filled that in March.” No signature. I printed it out and taped it to my monitor, metaphorically, and the career-page check became a hard rule that day.

Then we did it properly. For a full quarter, the team watched two title patterns (“Head of RevOps” and “Revenue Operations Manager”) across a 200-account list split between the DACH region and the US. Weekly runs, delta threshold of two, career-page verification before every send.

→ 200 accounts watched → 14 hiring surges detected → 11 verified and sent → 5 real conversations

Those eleven emails got the warmest replies of our year; several opened with some version of “good timing, we’re just setting this up.” Of course they were. The posting had already told us the timing, and the message talked about their problem instead of our monitoring. That quarter converted me from “hiring signals sound clever” to “why is anyone doing outbound without them.”

Total running cost for the quarter, by the way: two searches a week at 2 credits each, plus a handful of career-page checks. The whole detection layer cost less than one bad conference lunch. The expensive part was the discipline: waiting for verified surges instead of blasting the full 200-account list. It always is.

How this guide was put together

The parameters, response fields, credit costs (2 per jobs search, 3 per career-page record), and the 100-requests-per-minute fixed window come from the live API documentation, checked in August 2026. Workflow numbers are from my own team’s runs; your ratios will differ. Macro claims are linked to their sources: SHRM, the Bureau of Labor Statistics, LinkedIn’s Economic Graph, HubSpot, and the documented ghost-job phenomenon. And the standing limitation, stated honestly: posting data reflects what companies choose to publish. Ghost and evergreen postings exist, which is why this workflow trusts deltas and source checks over raw counts.

Frequently asked questions

How is this different from buying intent data?

Intent data infers interest from browsing behaviour. Hiring signals are a public statement of intent: the company literally published what they’re building. Weaker coverage, much stronger evidence. In practice the two complement each other: intent for breadth, hiring for confidence.

How often should I run it?

Weekly. Postings don’t turn over fast enough to justify daily runs, and weekly gives your delta calculation something meaningful to measure. The exception is a short, named campaign: during a launch you might run twice weekly and accept the noise.

Can I combine hiring with other signals?

That’s where it gets good. A company that raised recently AND is hiring for the team you sell to is a much stronger trigger than either alone. Pair this with the funding endpoint and require both.

What’s the rate limit?

100 requests per minute per key, on a fixed 60-second window. A weekly job search across several titles is nowhere near that, so this workflow is cheap to run. Details in usage limits.

What is a hiring signal?

A hiring signal is a change in a company’s job postings (a new role, a surge, a first-ever position) read as evidence of growth and upcoming spending. The posting itself is the data; the signal is what the change means for whoever sells to that team.

Are job postings still a reliable buying signal?

Yes, with discipline. Ghost and evergreen postings are real, which is why raw counts mislead. Deltas measured weekly, a career-page check before sending, and agency filtering keep the false positives manageable, and a verified hiring surge remains one of the strongest public signals a company emits.

Do I need to scrape job boards to do this?

No. That’s the point of the API layer. Scraping boards means maintaining parsers, dodging blocks, and joining company data yourself. A jobs API returns live postings already matched to firmographics in one response, for 2 credits a search. Save the scraping energy for problems that don’t have an endpoint.

Pick one role and watch it

Choose the single job title that means “this company now needs what I sell.” Run the search once a week for a month.

You’ll end up with a small list of companies that are visibly building in your direction, and reaching out to them is a much easier conversation than reaching out to a cold list that happened to match a filter.

One role. One country. One weekly cron. That’s the whole starting lineup, and a month from now you’ll have the timing advantage almost nobody in your market is using. Go set the watcher up.