How to Use Claude to Spot Sales Signals and Time Your Outreach (2026 Guide)

Claude sorts the sales signals a watcher catches on your accounts into act, wait or ignore, with a reason.

Published

Written by

Chris Pisarski

Reviewed by

Manmohit Grewal

Read time

23

minutes

One watcher alert, the right call: Claude reads each change next to the deal notes and returns act (a champion on a deal left: call today, draft ready), wait (a new CISO: reach out in a few weeks) or ignore (SOC analyst roles: not the buying group), each with a one-line reason.

Claude sorts the sales signals a watcher catches on your accounts into act, wait or ignore, with a reason. A signal here is a change such as a buyer leaving, a new executive or a funding round.

This guide shows which signals to watch on a named account list, and how to set up Claude to sort the alerts before a rep sees them. Checking accounts by hand misses moves, and switching on every alert buries reps.

A watcher can tell you that a Head of Security left one of your accounts. It can't tell you she was the champion on a deal in security review, which makes it a call for today. Claude reads the alert next to your deal notes and returns act, wait or ignore, with a one-line reason the rep can check.

A leader at a government digital services firm told our team about a large deal at an agency. "The CIO just stepped down in the middle of the week, took us three days to realize that."

The hard part is volume. A headcount rule set to changed can fire on every check for every account. A leader at a sales-intelligence startup told our team that "no seller wants more." So most of this guide is about rules that fire once per real event.

At a glance:

  • Watch closely: executives leaving accounts where you have an open deal or a renewal.

  • Batch weekly: champions changing companies, new job posts in your buyer's function.

  • Don't watch on their own: headcount changes, follower counts, total funding figures.

  • Act the same day on: a buyer leaving an open deal.

  • Wait two to four weeks on: a new executive in your buying role.

  • What Claude adds: a decision and a one-line reason per alert, read against your deal notes.

  • What a watcher costs: 5 credits per changed person at the default freshness, 150 at daily freshness.

  • Best fit: sellers and RevOps teams who want signals sorted by Claude before reps see them.

What are sales signals?

Sales signals are observable changes at an account, or in the people there, that suggest a need just appeared. Sellers use them to decide which account to contact and when.

This guide covers changes at the accounts and people on your list, and the examples below show the common ones. Topic research from third-party intent data lives with intent vendors, which the tools section names.

What's the difference between sales signals, buying signals and intent signals?

Sales signals, buying signals and intent signals differ mostly in who's looking and what they measure:

Term

What it usually means

Typical examples

Sales signals

Any change a seller uses to pick an account and a moment

Funding, a new VP, a hiring push, a new tool

Buying signals

Signs a buyer is moving toward a purchase

A demo request, pricing questions, a new person joining the buying group

Intent signals

Research behavior on a topic, often from third-party data

Reading reviews in your category, a topic surge on publisher sites

Intent data has its own guide on our blog, the B2B intent data guide, which covers first-party and third-party intent in depth.

What are examples of sales signals?

Sales signal examples include a funding round, a champion changing jobs, a post about your problem and a pricing-page visit. They come from five places, and four of them can be watched from outside the account:

  • Companies raise and hire. A new funding round, crossing a headcount size, a burst of job posts.

  • People move. A new executive in your buying role, a buyer leaving, a champion moving to a new company.

  • Companies adopt tools. A company starts using a tool your product connects to or replaces.

  • People post. Someone at the account posts about the problem you solve.

  • Buyers engage with you. Pricing-page visits, trial sign-ups, product usage.

The first four come from public data. The fifth lives in your own analytics, and tools such as Common Room and Demandbase are built for it. Hiring has its own post, hiring signals and how to track them.

Which sales signals are worth a watcher, and which fire too often?

Departures, champion moves and funding rounds deserve a watcher, while headcount and follower counts fire too often. The first group fires once per real event, and the second tracks a number that moves on most checks.

A watcher is a saved rule that re-checks a list of people or companies, or re-runs a search, on a schedule and sends only what changed.

The firing column follows Crustdata's watcher docs for people, companies, jobs and posts, and the last two columns are our recommendations:

Signal

What it tells you

How often it fires

Worth a watcher?

How to set it

A buyer or executive leaves an account with an open deal or renewal

The buying group just changed

Only when the person moves to a new employer

Yes, at daily freshness, for the few people on open deals

Person watch on named people, keyed to employer

A new VP or C-level starts in your buying role

A new budget owner with new priorities

Once per person who newly matches the search

Yes, then wait before reaching out

Person discovery watch on title plus a recent job change

A champion moves to a new company

A warm path into a new account

On a move, and on a promotion, because this watch has no keys

Yes, in a weekly digest

Person watch on your champion list, with no keys

A title change or promotion

More scope, or a reworded title

On every promotion or role change at the same employer

Only for champions

Track the employer change instead for everyone else

A new funding round

New budget, and hiring often follows

Once per new round when keyed to round type and date

Yes, paired with a hiring signal

Company watch on funding milestones

Total funding changed

The total figure moved

Every time the figure differs from the last check

No

Use funding milestones instead

Headcount changed

Very little on its own

Every time the count differs from the last check

No

Use a size threshold instead

Headcount crosses a size band

The account just entered your target size

Once, on the check where it first crosses

Yes

Company watch with a threshold

A job post that implies your product

The need has a budget

Once per new matching post

Yes, narrowed by title and read weekly

Job discovery watch on title and company filters

Open-role count changed

Hiring moved, up or down

Every time the count differs from the last check

Not alone

Combine with a size threshold

A tool you connect to or replace appears

They bought a complement or a rival

Once per company that newly matches

Yes, if your plan includes technographics

Company discovery watch on the technology name

A news mention

Anything from a launch to a lawsuit

Every new article, and again for a reposted copy unless keyed

Only with keys and a Claude filter

Company watch on news, keyed to article URL

A post that mentions your problem

Someone is talking about the pain

Once per new matching post

Narrowly, read weekly

Social post watch on a keyword plus the author's title

Follower or connection count changed

Popularity only

On most checks for an active profile

No

Use a threshold if you need it at all

A third-party topic surge

Research activity in your category

Set by your intent vendor

Use your intent vendor

See the intent data guide

Pricing-page visits

Someone at the account is looking at your price

As often as visitors arrive

Not public data

Your analytics or a first-party tool

Why do some signals fire on every check?

Signals built on a number that moves fire every time the number moves. A watcher that tracks a count with "changed" compares it to the last check. Every refresh that shows a different count sends you a note. Crustdata's docs warn that changed on a counter that moves often can fire on every check.

A threshold stops the repeat alerts. A comparison such as "headcount at least 200" fires once, on the check where the company first crosses it. It stays silent while the count stays above.

Why does a job-change alert fire on promotions too?

A job-change watcher fires on promotions because a new title at the same employer counts as a new role. Crustdata's docs explain that a promotion gets a fresh position ID, so a plain "new role added" rule fires and bills for it.

Adding keys to the rule, the employer's ID and name, makes it fire only when the employer is new. On your champion list, leave the keys off, because a champion promoted to Head of Security may now own the budget.

Why do funding and news alerts fire twice?

News and funding alerts fire twice when the same item arrives under a second identity. A syndicated article reposted at a new URL looks like a new article, and the watch fires again and charges again.

Keys stop both kinds of repeat. Key news on the article URL, and key funding rounds on round type plus date, so a restated round stays silent. The docs add that a watch remembers every identity it has seen, so an article seen once never fires again.

Is a funding announcement already too late?

A funding announcement is still worth an email when it arrives with a second signal, such as hiring. Every vendor in your market sees the announcement the same day.

Someone at a commercial real estate brokerage said a Series B "deserves an email today." Someone at a contract talent firm said the opposite. "As soon as a company has announced that they've raised money, you're too late, right?"

A Series B tells you there's budget. It doesn't tell you the CISO is shopping for a security tool. So wait for a second signal, such as security job posts at the account in the following weeks, before you reach out.

How fast should you act on each sales signal?

Act the same day only when a person on an open deal moves. Most other signals can wait for a daily or weekly digest, and a new executive is worth a deliberate wait.

The windows below are our recommendations, built on what the sellers quoted in this section told our team:

Signal

When to act

Why

A buyer leaves an account with an open deal or renewal

Same day

The deal changed, and a competitor may hear first

A champion moves to a new company

Within the week

The move doesn't touch a live deal, so a weekly digest is enough

A new executive starts in your buying role

Two to four weeks after the start date

They're still learning the job

A new funding round

Within a few days if a second signal is there, otherwise wait for one

Every vendor sees the announcement

Job posts in your buyer's function

Weekly

A week of posts reads better as one list

A tool adopted or a size band crossed

Weekly

The change is slow, and a day rarely matters

Should every alert be real time?

Real-time alerts are only worth it for the handful of people on deals you're working now. Someone on the go-to-market team at a government-contracting software company told our team about missing a move. "We go to renewal and the VP is like, oh, our VP is gone."

For everyone else, a digest works better. The same person told our team they wanted customer job changes as one weekly list. A team at a large e-commerce ad-tech company we talked to planned one threaded post per day. That way alerts wouldn't bury client conversations.

When should you wait before reaching out?

Wait two to four weeks after a new executive starts. The founder of a software company for mortgage lenders told our team why. "If somebody hires a new CRO, we don't actually want to reach out the day that they get hired." They'd rather wait "two, three weeks, maybe a month."

The new-executive watcher still fires on day one. Your routing code sets the task's due date to the new executive's start_date plus 21 days. Claude reads the new executive's past roles against your account notes. It writes what the rep should know on that date, such as a last employer that used a rival product.

How fresh does each watcher need to be?

Use daily freshness for the people on open deals and renewals, and the 30-day default for everyone else. A person watch keeps its tracked profiles 30, 14, 7, 3 or 1 days fresh, and the default is 30 days.

Fresher costs more per change, from 5 credits per changed person at the 30-day default to 150 at daily. So the running example in Step 1 keeps daily freshness for its 10 deal contacts only.

How does Claude fit into a sales signal workflow?

Claude sits between the alert and the rep, and judges what the watcher found. A watcher checks your accounts and people on a schedule and sends only what changed, to a webhook, Slack, Google Chat or email. Each part of the workflow has one owner:

Part

Who does it

What it produces

Watching for changes

The data source (Crustdata watchers here)

One notification per change

Filtering by title, size, country and employer

The data source, with keys and filters

Only changes inside your plan

Deciding act, wait or ignore from your notes

Claude

A decision and a reason

Routing and due dates

Your code or your CRM

A task on the account owner, due on the right day

Writing the first line

Claude

A draft opening tied to the signal

Sending

The rep

The email

The buying signal detection page shows the product side of the watching step.

How do sales teams already use Claude or other models with signals?

Teams we talked to give a model the jobs a filter can't do. Three came up:

  • Judging fit from text no field holds. A public-sector sales-intelligence startup had a model read each company's website and case studies. The model scored how much the company sells to state and local government and education, with its reasoning. Any industry can sell there, so an industry filter couldn't do it.

  • Finding a signal buried in a long document. Someone at a commercial real estate brokerage gave Claude a list of companies. They asked for "a needle in a haystack type of signal that I would never see." Claude found a CEO's plan, in an annual filing, to expand the company's New York operation.

  • Reading the account's own history. A sales leader at a large e-commerce ad-tech company wanted reps to ask an agent who the senior buyers are at each account they own. The agent would then read the CRM and call history for each person.

In a signal workflow, the model first needs a list of what changed, and that list is the watcher's job.

Can't I just ask Claude which accounts have new signals?

Claude can't find new signals alone, because it doesn't compare your accounts from one day to the next. On its own, it answers from what it learned up to its training cutoff or from a web search.

A watcher supplies the list of what changed by checking your data on a schedule. Claude then judges what each change means for your deals.

Someone at an offshore hiring services company told our team about their Claude routine. Each morning it checks job boards for new posts at small startups with no HR lead. It found good accounts, but "it's not able to find new accounts every day."

Which route should you build on?

Use Claude Code with the MCP server if you write code, and Claude Cowork if you don't. Pick the Claude API when alerts have to reach your CRM without anyone opening Claude, and expect all three to use the same Crustdata data.

What you'll need:

  • A Crustdata account. New self-serve accounts get free credits.

  • Claude Code, a paid Claude plan for Cowork, or an Anthropic API key.

  • A list of your open deals, target accounts and champions.

  • Somewhere for alerts to go: Slack, email or your CRM.

Option A: Claude Code with the Crustdata MCP server

Claude Code with the MCP server suits anyone who writes code. Add the MCP server from your terminal, then type /mcp inside Claude Code, pick crustdata and sign in:

claude mcp add --transport
claude mcp add --transport
claude mcp add --transport

Or install the Crustdata plugin, which adds the same server plus ready-made skills:




In Claude Code you can describe a watch in plain English, such as "new AppSec job posts at my 100 accounts". Claude then writes the request body in Step 2.

Option B: Claude Cowork, for sellers who don't write code

Cowork is the route for a seller or RevOps lead working alone. Add Crustdata in Claude under Customize, then Connectors, then Add custom connector, with the URL https://install.crustdata.com/mcp (setup).

Then make it a scheduled task, which is available on all paid Claude plans. A Monday task can look up your champion list and open-deal contacts in Crustdata and compare each person's employer and title with last week's saved list. Claude judges open-deal changes against the Step 3 rules and checks whether each champion's new company or role fits your account plan (Step 1). You then get a short list with draft first lines.

Without a watcher, the task looks every person up again each week, so it spends enrichment credits every time.

Option C: The Claude API with a watcher webhook

The API route suits a GTM engineer who can host a webhook. Each watcher you point at the webhook posts its changes there. Your handler passes each change to Claude with tool use or a plain prompt, then writes the result to the CRM.

Step 1: Which accounts and people should you watch?

Watch the people on open deals and renewals first, then buyers at your target accounts, then your champions. Every name you add costs credits when it changes, so start with the plan you already sell against.

Someone at an AI CRM startup told our team that customers care about "people within the personas that they sell to the most." So scope every watch to your buying group, and leave everyone else out.

What does the account plan look like for a security vendor?

The running example is an application security (AppSec) vendor with 100 named target accounts. Let's say its plan reads like this:

  • What you sell. A platform that finds and ranks security flaws in code, priced per developer.

  • Who you sell to. US software companies with 200 to 2,000 employees and an in-house security team.

  • Open pipeline. 3 open deals (one in technical evaluation, one in security review, one in procurement) and 2 renewals due within 90 days.

  • Buying group. The CISO or VP Security signs, and the Head of AppSec or Product Security champions. A senior AppSec or DevSecOps engineer leads the technical evaluation. The VP Engineering approves anything that touches developer workflow.

  • Near the list. 50 accounts at 150 to 199 employees, which join the list when they reach 200.

  • Champions. 40 former users of your product who now work at other companies.

  • Out of scope. Companies outside the US or under 200 employees, subsidiaries of current customers and do-not-contact accounts. Accounts that signed a rival for several years in the last 12 months are out too.

Which lines go to a watcher, and which only Claude can judge?

Each line of the plan goes to the cheapest tool that can handle it:

Line in the plan

Who handles it

How

The 10 people on the 3 open deals and 2 renewals

Person watch, daily freshness

Keyed to employer, fires on a move

290 more buyers at the 100 accounts, about 3 each

Person watch, 30-day freshness

Keyed to employer

The 40 former champions

Person watch, 30-day freshness, no keys

A move or a promotion fires

A new CISO, VP Security or Head of AppSec at any of the 100

Person discovery watch

Title, seniority and recent job change

AppSec or DevSecOps job posts at the 100

Job discovery watch, weekly

Title filter on the 100 domains

Software engineer job posts at the 100

Job discovery watch, weekly

Same filter with engineering titles, since more developers means more seats

A new funding round at the 100

Company watch

Funding milestones keyed to round type and date

The 50 near-list accounts reaching 200 employees

Company watch

A threshold, fires once

US only, 200 to 2,000 employees, buyer titles

Filters

The data handles these alone

Is a "security engineer" post AppSec work, or a SOC, GRC or IT role?

Claude

Reads the job description

Was the person who left the signer, the champion or a side contact?

Claude

Reads the deal notes

Did the account sign a rival last year, or is it a subsidiary of a customer?

Claude

Reads the account notes

Which proof point opens the first line

Claude

Writes from the signal and the deal

If you already pay for a job-change tool, keep its list. Use watchers for the signals it doesn't cover, so reps don't get the same move twice.

Step 2: How do I set up a watcher for each signal?

Set up one watcher per signal, using the keys and thresholds from the signal table. Each request below follows the examples in Crustdata's docs.

The people on open deals and renewals. This person watch fires only when someone moves to a new employer, and keeps the data refreshed daily:

{
  "entities": { "professional_network_profile_urls": ["PROFILE_URL_1", "PROFILE_URL_2"] },
  "track": {
    "field": "experience.employment_details.current",
    "type": "added",
    "keys": ["crustdata_company_id", "name"]
  },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 24 }, "refresh_frequency_days": 1 },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}
{
  "entities": { "professional_network_profile_urls": ["PROFILE_URL_1", "PROFILE_URL_2"] },
  "track": {
    "field": "experience.employment_details.current",
    "type": "added",
    "keys": ["crustdata_company_id", "name"]
  },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 24 }, "refresh_frequency_days": 1 },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}
{
  "entities": { "professional_network_profile_urls": ["PROFILE_URL_1", "PROFILE_URL_2"] },
  "track": {
    "field": "experience.employment_details.current",
    "type": "added",
    "keys": ["crustdata_company_id", "name"]
  },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 24 }, "refresh_frequency_days": 1 },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}

Send it to POST https://api.crustdata.com/watch/person with your API key and the x-api-version: 2025-11-01 header. Drop refresh_frequency_days for the 290 buyers, and they use the default 30 days.

The former champions. This person watch has no keys, so it fires on a move and on a promotion at the same employer. It checks weekly at the default 30-day freshness:

{
  "entities": { "professional_network_profile_urls": ["CHAMPION_URL_1", "CHAMPION_URL_2"] },
  "track": { "field": "experience.employment_details.current", "type": "added" },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "slack", "webhook_url": "https://hooks.slack.com/services/YOUR/HOOK" } ]
}
{
  "entities": { "professional_network_profile_urls": ["CHAMPION_URL_1", "CHAMPION_URL_2"] },
  "track": { "field": "experience.employment_details.current", "type": "added" },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "slack", "webhook_url": "https://hooks.slack.com/services/YOUR/HOOK" } ]
}
{
  "entities": { "professional_network_profile_urls": ["CHAMPION_URL_1", "CHAMPION_URL_2"] },
  "track": { "field": "experience.employment_details.current", "type": "added" },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "slack", "webhook_url": "https://hooks.slack.com/services/YOUR/HOOK" } ]
}

Send it to the same endpoint, POST https://api.crustdata.com/watch/person.

The near-list accounts reaching 200 employees. This company watch fires once when headcount first reaches 200:

{
  "entities": { "domains": ["near-list-1.com", "near-list-2.com"] },
  "track": { "field": "headcount.total", "type": "=>", "value": 200 },
  "fields": ["basic_info", "headcount"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "slack", "webhook_url": "https://hooks.slack.com/services/YOUR/HOOK" } ]
}
{
  "entities": { "domains": ["near-list-1.com", "near-list-2.com"] },
  "track": { "field": "headcount.total", "type": "=>", "value": 200 },
  "fields": ["basic_info", "headcount"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "slack", "webhook_url": "https://hooks.slack.com/services/YOUR/HOOK" } ]
}
{
  "entities": { "domains": ["near-list-1.com", "near-list-2.com"] },
  "track": { "field": "headcount.total", "type": "=>", "value": 200 },
  "fields": ["basic_info", "headcount"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "slack", "webhook_url": "https://hooks.slack.com/services/YOUR/HOOK" } ]
}

For new rounds at the 100 accounts, track funding.milestones with "type": "added" and "keys": [["round_type", "date"]] on the same endpoint, POST https://api.crustdata.com/watch/company.

AppSec job posts at the 100 accounts. A job watch re-runs a job search and sends new matches. This one checks weekly and returns the description, so Claude can tell AppSec work from other security roles:

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "company.basic_info.primary_domain", "type": "in", "value": ["account-1.com", "account-2.com"] },
      {
        "op": "or",
        "conditions": [
          { "field": "job_details.title", "type": "(.)", "value": "application security" },
          { "field": "job_details.title", "type": "(.)", "value": "product security" },
          { "field": "job_details.title", "type": "(.)", "value": "DevSecOps" }
        ]
      }
    ]
  },
  "fields": ["job_details.title", "job_details.url", "content.description", "company.basic_info.name", "company.basic_info.primary_domain"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 }, "max_results_per_run": 25 },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "company.basic_info.primary_domain", "type": "in", "value": ["account-1.com", "account-2.com"] },
      {
        "op": "or",
        "conditions": [
          { "field": "job_details.title", "type": "(.)", "value": "application security" },
          { "field": "job_details.title", "type": "(.)", "value": "product security" },
          { "field": "job_details.title", "type": "(.)", "value": "DevSecOps" }
        ]
      }
    ]
  },
  "fields": ["job_details.title", "job_details.url", "content.description", "company.basic_info.name", "company.basic_info.primary_domain"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 }, "max_results_per_run": 25 },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "company.basic_info.primary_domain", "type": "in", "value": ["account-1.com", "account-2.com"] },
      {
        "op": "or",
        "conditions": [
          { "field": "job_details.title", "type": "(.)", "value": "application security" },
          { "field": "job_details.title", "type": "(.)", "value": "product security" },
          { "field": "job_details.title", "type": "(.)", "value": "DevSecOps" }
        ]
      }
    ]
  },
  "fields": ["job_details.title", "job_details.url", "content.description", "company.basic_info.name", "company.basic_info.primary_domain"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 }, "max_results_per_run": 25 },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}

Send it to POST https://api.crustdata.com/watch/job/search.

Developer hiring at the 100 accounts. For a vendor priced per developer, a burst of engineering posts means more code to secure and more seats. Someone at an application-security company explained the chain to our team. "If they are hiring more developers, they are creating more apps, which means they will need more security."

Copy the job watch above, swap the titles for "software engineer", and send it to the same endpoint. Both job watches post to your webhook, so the Step 4 handler sees each new post.

New security executives at the 100 accounts. A person discovery watch sends people who newly match a search. Send this one to POST https://api.crustdata.com/watch/person/search:

{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "experience.employment_details.current.company_website_domain", "type": "in", "value": ["account-1.com", "account-2.com"] },
      { "field": "experience.employment_details.current.seniority_level", "type": "in", "value": ["CXO", "Vice President", "Director"] },
      {
        "op": "or",
        "conditions": [
          { "field": "experience.employment_details.current.title", "type": "(.)", "value": "security" },
          { "field": "experience.employment_details.current.title", "type": "(.)", "value": "AppSec" }
        ]
      },
      { "field": "recently_changed_jobs", "type": "=", "value": true }
    ]
  },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "experience.employment_details.current.company_website_domain", "type": "in", "value": ["account-1.com", "account-2.com"] },
      { "field": "experience.employment_details.current.seniority_level", "type": "in", "value": ["CXO", "Vice President", "Director"] },
      {
        "op": "or",
        "conditions": [
          { "field": "experience.employment_details.current.title", "type": "(.)", "value": "security" },
          { "field": "experience.employment_details.current.title", "type": "(.)", "value": "AppSec" }
        ]
      },
      { "field": "recently_changed_jobs", "type": "=", "value": true }
    ]
  },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}
{
  "filters": {
    "op": "and",
    "conditions": [
      { "field": "experience.employment_details.current.company_website_domain", "type": "in", "value": ["account-1.com", "account-2.com"] },
      { "field": "experience.employment_details.current.seniority_level", "type": "in", "value": ["CXO", "Vice President", "Director"] },
      {
        "op": "or",
        "conditions": [
          { "field": "experience.employment_details.current.title", "type": "(.)", "value": "security" },
          { "field": "experience.employment_details.current.title", "type": "(.)", "value": "AppSec" }
        ]
      },
      { "field": "recently_changed_jobs", "type": "=", "value": true }
    ]
  },
  "fields": ["basic_profile", "experience"],
  "config": { "trigger": { "type": "interval", "every_hours": 168 } },
  "notifications": [ { "type": "webhook", "url": "https://your-app.com/webhooks/crustdata" } ]
}

recently_changed_jobs marks people whose previous role ended within 90 days of the last index rebuild. Filtering on it works on any account, and returning the field is enabled per account (person search reference).

A tool adopted uses a company discovery watch on technographics.technologies.name, which needs technographics access on your key.

How do I test a watcher before it goes live?

Send each watch a test notification before it goes live. Each watch has a test endpoint that pushes one sample through your receiver. You can check parsing and routing without waiting for a real change.

Crustdata's watchers also send a free baseline sample on the first check, with up to five records, so reps see the format early. Tell reps how often to expect an alert from each watcher. The founder of a GTM AI agency told our team that a client who gets no signals for a couple of days will ask whether the feed is working.

Step 3: How do I get Claude to decide act, wait or ignore?

Give Claude your account plan and judgment calls, and ask for fixed JSON your code can route. Simple rules belong in the watch. Keys already drop title changes at the same employer on the buyer watches. Filters already handle size, country and titles, so Claude only sees changes that need reading.

Start from this prompt, with each account's deal and account notes attached:







Return JSON only:
[{"index": 0, "signal": "departure|new_executive|security_job|engineering_job|funding|other",
  "decision": "act|wait|ignore", "reason": "one line naming the change and the note it rests on",
  "owner_email": "from the account notes or null"}]
Return JSON only:
[{"index": 0, "signal": "departure|new_executive|security_job|engineering_job|funding|other",
  "decision": "act|wait|ignore", "reason": "one line naming the change and the note it rests on",
  "owner_email": "from the account notes or null"}]
Return JSON only:
[{"index": 0, "signal": "departure|new_executive|security_job|engineering_job|funding|other",
  "decision": "act|wait|ignore", "reason": "one line naming the change and the note it rests on",
  "owner_email": "from the account notes or null"}]

In Claude Code, save the rules as a skill at .claude/skills/signal-triage/SKILL.md, so Claude can load them when it triages an alert. At a large e-commerce ad-tech company we talked to, the go-to-market team already builds its own Claude skills. Their sales leader asked for an account-mapping skill that includes people data.

Log every decision with its reason, and review the log monthly to find the rules that sent reps alerts they ignored.

Step 4: How do I route an alert to the account owner in the CRM?

Match the alert to a CRM account by company domain, look up the owner, and create a task. The shape below follows Crustdata's webhook docs.

What does a watcher payload look like, and how do I handle it?

Each notification is a POST with a metadata block and results. An entity watch sends a results list, each item with changes and a record. A discovery watch sends the new people or jobs under results.added. A sample job-change notification from a person watch, trimmed, looks like this:

{
  "metadata": { "watch_id": 50991, "kind": "entity", "dataset": "person", "run_id": 1785211467,
                "notification_id": "ntf_1785211467" },
  "results": [
    { "changes": [ { "field": "experience.employment_details.current", "type": "added",
                     "new_elements": [ { "name": "New Employer Inc", "title": "VP Security",
                                         "start_date": "2026-10-01", "crustdata_company_id": 1234 } ] } ],
      "record": { "crustdata_person_id": 6324687, "basic_profile": { "name": "Sample Person" } } }
  ]
}
{
  "metadata": { "watch_id": 50991, "kind": "entity", "dataset": "person", "run_id": 1785211467,
                "notification_id": "ntf_1785211467" },
  "results": [
    { "changes": [ { "field": "experience.employment_details.current", "type": "added",
                     "new_elements": [ { "name": "New Employer Inc", "title": "VP Security",
                                         "start_date": "2026-10-01", "crustdata_company_id": 1234 } ] } ],
      "record": { "crustdata_person_id": 6324687, "basic_profile": { "name": "Sample Person" } } }
  ]
}
{
  "metadata": { "watch_id": 50991, "kind": "entity", "dataset": "person", "run_id": 1785211467,
                "notification_id": "ntf_1785211467" },
  "results": [
    { "changes": [ { "field": "experience.employment_details.current", "type": "added",
                     "new_elements": [ { "name": "New Employer Inc", "title": "VP Security",
                                         "start_date": "2026-10-01", "crustdata_company_id": 1234 } ] } ],
      "record": { "crustdata_person_id": 6324687, "basic_profile": { "name": "Sample Person" } } }
  ]
}

The request carries an x-crustdata-signature header, an HMAC-SHA256 over the timestamp and the raw body, keyed by your API key. A minimal handler checks the signature, skips any notification ID it has already processed, hands the results to Claude, and sets each due date itself:

import hmac, hashlib, json, time
from datetime import date, timedelta
import hmac, hashlib, json, time
from datetime import date, timedelta
import hmac, hashlib, json, time
from datetime import date, timedelta
API_KEY = "YOUR_API_KEY"
seen_ids = set()  # use a database table in production
API_KEY = "YOUR_API_KEY"
seen_ids = set()  # use a database table in production
API_KEY = "YOUR_API_KEY"
seen_ids = set()  # use a database table in production
def verify(headers, raw_body):
    parts = dict(p.split("=", 1) for p in headers["x-crustdata-signature"].split(","))
    signed = f"{parts['t']}.{raw_body.decode()}".encode()
    expected = hmac.new(API_KEY.encode(), signed, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, parts["v1"]) and abs(time.time() - int(parts["t"])) < 300
def verify(headers, raw_body):
    parts = dict(p.split("=", 1) for p in headers["x-crustdata-signature"].split(","))
    signed = f"{parts['t']}.{raw_body.decode()}".encode()
    expected = hmac.new(API_KEY.encode(), signed, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, parts["v1"]) and abs(time.time() - int(parts["t"])) < 300
def verify(headers, raw_body):
    parts = dict(p.split("=", 1) for p in headers["x-crustdata-signature"].split(","))
    signed = f"{parts['t']}.{raw_body.decode()}".encode()
    expected = hmac.new(API_KEY.encode(), signed, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, parts["v1"]) and abs(time.time() - int(parts["t"])) < 300
WAIT_DAYS = {"departure": 7, "engineering_job": 14, "funding": 14}
WAIT_DAYS = {"departure": 7, "engineering_job": 14, "funding": 14}
WAIT_DAYS = {"departure": 7, "engineering_job": 14, "funding": 14}
def due_date(d, result):
    if d["decision"] == "act":
        return date.today()
    if d["signal"] == "new_executive":  # start_date of the primary current role, plus 21 days
        rec = result.get("record", result)  # entity watches wrap the person in "record"
        roles = rec["experience"]["employment_details"]["current"]
        role = next((r for r in roles if r.get("is_default")), roles[0])
        return date.fromisoformat(role["start_date"][:10]) + timedelta(days=21)
    return date.today() + timedelta(days=WAIT_DAYS.get(d["signal"], 7))
def due_date(d, result):
    if d["decision"] == "act":
        return date.today()
    if d["signal"] == "new_executive":  # start_date of the primary current role, plus 21 days
        rec = result.get("record", result)  # entity watches wrap the person in "record"
        roles = rec["experience"]["employment_details"]["current"]
        role = next((r for r in roles if r.get("is_default")), roles[0])
        return date.fromisoformat(role["start_date"][:10]) + timedelta(days=21)
    return date.today() + timedelta(days=WAIT_DAYS.get(d["signal"], 7))
def due_date(d, result):
    if d["decision"] == "act":
        return date.today()
    if d["signal"] == "new_executive":  # start_date of the primary current role, plus 21 days
        rec = result.get("record", result)  # entity watches wrap the person in "record"
        roles = rec["experience"]["employment_details"]["current"]
        role = next((r for r in roles if r.get("is_default")), roles[0])
        return date.fromisoformat(role["start_date"][:10]) + timedelta(days=21)
    return date.today() + timedelta(days=WAIT_DAYS.get(d["signal"], 7))
def handle(headers, raw_body):
    if not verify(headers, raw_body):
        return 401
    event = json.loads(raw_body)
    note_id = event["metadata"]["notification_id"]
    if note_id in seen_ids:
        return 200  # a repeat delivery of something already handled
    seen_ids.add(note_id)
    raw = event["results"]
    results = raw["added"] if isinstance(raw, dict) else raw  # discovery vs entity watches
    decisions = triage_with_claude(results)  # the Step 3 prompt, plus the account notes
    for d in decisions:
        if d["decision"] != "ignore":
            d["due"] = due_date(d, results[d["index"]])
            create_crm_task(d)  # match by domain, assign to the owner, due on d["due"]
        log_for_digest(d)  # every decision, ignores included, feeds the daily digest
    return 200
def handle(headers, raw_body):
    if not verify(headers, raw_body):
        return 401
    event = json.loads(raw_body)
    note_id = event["metadata"]["notification_id"]
    if note_id in seen_ids:
        return 200  # a repeat delivery of something already handled
    seen_ids.add(note_id)
    raw = event["results"]
    results = raw["added"] if isinstance(raw, dict) else raw  # discovery vs entity watches
    decisions = triage_with_claude(results)  # the Step 3 prompt, plus the account notes
    for d in decisions:
        if d["decision"] != "ignore":
            d["due"] = due_date(d, results[d["index"]])
            create_crm_task(d)  # match by domain, assign to the owner, due on d["due"]
        log_for_digest(d)  # every decision, ignores included, feeds the daily digest
    return 200
def handle(headers, raw_body):
    if not verify(headers, raw_body):
        return 401
    event = json.loads(raw_body)
    note_id = event["metadata"]["notification_id"]
    if note_id in seen_ids:
        return 200  # a repeat delivery of something already handled
    seen_ids.add(note_id)
    raw = event["results"]
    results = raw["added"] if isinstance(raw, dict) else raw  # discovery vs entity watches
    decisions = triage_with_claude(results)  # the Step 3 prompt, plus the account notes
    for d in decisions:
        if d["decision"] != "ignore":
            d["due"] = due_date(d, results[d["index"]])
            create_crm_task(d)  # match by domain, assign to the owner, due on d["due"]
        log_for_digest(d)  # every decision, ignores included, feeds the daily digest
    return 200

Reject timestamps more than five minutes old, as the handler does. In HubSpot or Salesforce, create_crm_task finds the company by domain, reads its owner and creates a task due on the date due_date returns, with Claude's reason in the body.

Step 5: How do I find the right person once a company signal fires?

Search for people in your buying role at that company. A funding round or a size threshold names a company and no person, so the rep needs someone to write to.

A person search filtered on the company's domain and a seniority level such as "Vice President" returns them. Both filters sit in the Experience premium group. Claude needs past roles, so add experience to fields, and the search costs 0.23 credits per result at list price (pricing). Pull about five names per account.

Claude then picks who to write to first. It reads each person's title and past roles against your buying group. A Head of AppSec who used your product at a past job goes ahead of a CISO who has never seen it.

Step 6: How do I turn a signal into the first line of an email?

Ask Claude to write one opening line that names the change and connects it to one problem you solve. Keep it to that one change, so it reads as written for this person.

For example, for the AppSec job-post signal, the prompt might be: "Write one opening sentence to the Head of AppSec at this company. They posted three application security engineer roles in the last two weeks. We help small AppSec teams sort scanner findings without adding headcount. No flattery, under 25 words."

Step 7: How do I keep the alert volume down?

Cap each watcher, batch what can wait, and switch off watchers nobody acts on. Four controls do most of the work:

  • Cap each check. max_results_per_run limits how many notifications one check sends, 25 by default. On discovery watches, matches over the cap arrive on a later run unless you set overflow_policy to "drop" (job watch docs).

  • Slow the schedule. A weekly check suits size bands, tools and job posts.

  • Send a digest. Have Claude write one message per rep. Each alert gets a line on why it made the cut, and the message lists what Claude dropped.

  • Read the run history. Each watch reports notifications_count and credits_consumed, so you can see which ones fire most.

A daily digest that Claude writes from the day's decisions and due dates might read:




How do I know if the alerts are working?

Track each watcher from alert to touch to meeting. If a watcher's alerts rarely lead to a rep reaching out, change its rule or switch it off. Claude's logged reasons show which rule sent each alert, so you can fix that one rule.

How much does it cost to watch sales signals?

A list watcher costs 5 credits per change at the default 30-day freshness, and nothing when nothing changes. That rate is on Crustdata's pricing page, and the first check on every watch is a free baseline. Crustdata credits cost $0.30 to $0.01 per credit, lower depending on plan.

Each watcher's rate per change, from the same pricing page:

Watcher

Default freshness (30 days)

Daily freshness (1 day)

Person watch on a list you supply

5 credits per changed person

150 credits per changed person

Company watch on a list you supply

5 credits per changed company

Not available

Person discovery watch

0.5 credits per new person

150 credits per new person

Job discovery watch

0.5 credits per new job

150 credits per new job

Company discovery watch

2 credits per new company

150 credits per new company

Social post discovery watch

2 credits per new post

150 credits per new post

Our arithmetic for one example month of the security vendor's plan, at those list rates:

Change in the month

Watcher

Arithmetic

Credits

2 of the 10 people on open deals and renewals move

Person watch, daily

2 x 150

300

15 of the 330 other buyers and champions move

Person watch, 30 days

15 x 5

75

2 new security executives start at the 100 accounts

Person discovery watch

2 x 0.5

1

12 new AppSec job posts at the 100 accounts

Job discovery watch

12 x 0.5

6

30 new software engineer job posts at the 100 accounts

Job discovery watch

30 x 0.5

15

1 account raises a round or reaches 200 employees

Company watch

1 x 5

5

Total



402

How can I cut the bill?

Use daily freshness only on deal contacts, which take 300 of the example month's 402 credits. Three more habits help:

  • Track counts with a threshold. A threshold fires once. A count set to changed fires again and again, and each fire is billed.

  • Add keys. Keys stop a promotion, a reposted article or a restated round from billing a second time.

  • Check how often a watch fires. The run history shows credits consumed per watch, so you can retire the expensive ones.

Which other tools track sales signals, and when are they a better fit?

UserGems, Common Room and Bombora track sales signals, and each beats building your own for one job. Each one is the better pick for a particular team:

  • UserGems is the better fit for job-change tracking inside your CRM. It lists "30+ native signals" including job changes and shows them in Salesforce, HubSpot and Outreach (UserGems). Pick it if you'd rather not build anything.

  • Common Room is the better fit for first-party signals. It describes identifying "every signal across CRM, product, marketing, and engagement" (Common Room). Watchers don't see your website or product usage.

  • Bombora is the better fit for third-party topic intent. Its Company Surge data reflects research "across 14B+ monthly events and 5M company domains" (Bombora).

  • Demandbase suits ABM teams that want scoring in one platform. It uses AI to analyze "signals, accounts, and buying group activity" (Demandbase).

  • ZoomInfo suits teams that want signals and contact data in one seat. Its guide lists intent data across 4,500+ topics alongside its contact database (ZoomInfo).

  • Clay suits teams assembling signals from many providers. It offers data from "200+ data and AI vendors" in one marketplace (Clay).

Crustdata fits when you want people, company, job and post changes delivered to your own Claude workflow or product. It doesn't cover first-party website signals or third-party topic intent, and technographics needs access on your key.

Where do I start this week?

Start with the people on your open deals and renewals, because that's where a missed move costs the most. Then add the rest one signal at a time:

  • List the signer and champion on every open deal and renewal, and set up a daily person watch on them.

  • Write your judgment calls into the Step 3 prompt and save it as a Claude skill.

  • Add a weekly champion watch and one job watch for your buyer's function at your target accounts.

  • After two weeks, read the run history and switch off whatever reps ignored.

You can try it with the free credits on a new self-serve account, or book a demo at crustdata.com.

Sales signals FAQ

What is signal-based selling?

Signal-based selling is prospecting that picks accounts and timing from recent changes at those accounts. A rep reaches out because something happened, such as a new executive or a funding round, and the message names it.

Is signal-based selling just intent data with a new name?

Signal-based selling is broader than intent data, because it also acts on job changes, funding, hiring and new tools. Those opportunity signals can be checked against a named list of accounts. Topic intent usually arrives from a vendor such as Bombora as a list of in-market accounts. Test any topic surge against your closed-won deals before you route it to reps.

How do you avoid false positives with sales signals?

Sales signal false positives drop when keys and thresholds stop the repeat fires and Claude drops the off-target ones. Before a new watcher reaches reps, check one week of its alerts against your open deals and switch off any rule nobody would have acted on.

How quickly should you respond to a buying signal?

Respond to a first-party buying signal, such as a demo request or a pricing question, within the hour. In Harvard Business Review research, firms that tried to reach a lead within an hour were nearly seven times as likely to qualify it as firms that tried an hour later. The public signals in this guide follow the timing table above.

Who wrote this?

Chris Pisarski is a co-founder of Crustdata and writes about how sales, recruiting and investment teams use real-time data. Manmohit Grewal, co-founder, leads engineering at Crustdata.

Crustdata is now live in Claude!

Find the best leads, candidates and companies with only a prompt.

Sign In