Signal-based outbound: trigger sequences when an account starts researching
How to run outbound off intent signals: watch your accounts, catch the moment research starts, find the right buyer and route them to a sequence.
Dag Holmen · Updated · 5 min read
Signal-based selling means reaching out when something changes at an account, instead of working a static list on a fixed schedule. The strongest change you can catch is research: an account that wasn’t looking at your category last week and is looking now.
For a GTM engineer, that turns into a loop you can build and run on a schedule: watch a set of accounts, detect when research starts, find the right buyer, get their email and route them to a sequence. This guide walks through each step. The intent check is a placeholder until B2Benrich’s intent endpoints are documented. Everything after it uses endpoints that are live today.
The loop
- Watch a list of accounts that fit.
- Detect a new or rising intent signal.
- Find the people who own the problem.
- Reach them with a checked work email.
- Route them to the sequence that matches the topic.
- Hold off on accounts you’ve contacted recently.
Each run is one pass through the loop. Daily is a good default. It’s fast enough that you reach accounts while they’re still researching, and slow enough to keep the noise down.
Step 1: The watch list
Start with accounts that already fit your ICP. Your in-market account list is a good source, and so is your CRM’s target accounts view. Store one row per account with its domain, owner and the date you last contacted it.
Step 2: Detect the moment research starts
The trigger isn’t "this account has intent". It’s "this account’s intent changed". Compare each run to the state you stored last time and fire on one of these:
- A topic that’s new for this account.
- A clear jump in strength compared with the account’s own recent baseline.
- A first signal on a competitor name or a commercial topic like pricing or alternatives.
Then save the new state, so tomorrow’s run compares against today.
Step 3: Find the right buyer
For each triggered account, pull two or three people from POST /v1/search/company-employees. Filter by job_function, job_level or persona, and pick filter values that match the topic. A security topic points at a different buyer than a sales tool. Before you add anyone, check your CRM. If the account has an owner or an open deal, send the signal to that rep instead of starting a sequence.
Step 4: Get the email
POST /v1/enrich/person/name-domain-to-email returns { status, email } for a first name, last name and domain. Use only emails with a good status, and run a check before you send, as covered in email verification API.
Step 5: Route by topic
Map each topic to a sequence. The topic tells you which problem to write about, so one generic sequence for every trigger throws most of the value away.
Here’s the whole loop as one daily job:
import os, requests
from datetime import date, timedelta
BASE = "https://api.b2benrich.com"
HEADERS = {"X-Api-Key": os.environ["B2BENRICH_API_KEY"], "Content-Type": "application/json"}
COOLDOWN = timedelta(days=30)
SEQUENCE_BY_TOPIC = {
"sales engagement software": "seq-category",
"competitor-x alternatives": "seq-switching",
"outbound reply rates": "seq-problem",
}
def post(path, body):
r = requests.post(f"{BASE}{path}", json=body, headers=HEADERS, timeout=30)
r.raise_for_status()
return r.json()
def get_intent_signals(account_domains, topics):
# TODO: replace with the B2Benrich intent endpoint once it's documented.
# Return your own shape: [{"domain": ..., "topic": ..., "strength": ..., "seen_at": ...}]
return []
def run():
accounts = db.watch_list() # [{domain, owner, last_contacted}]
signals = get_intent_signals([a["domain"] for a in accounts], list(SEQUENCE_BY_TOPIC))
for sig in signals:
account = db.account(sig["domain"])
if not is_new_or_rising(sig, db.last_state(sig["domain"], sig["topic"])):
continue
db.save_state(sig)
if account["owner"]:
crm.create_task(account["owner"], f"New research on {sig['topic']}")
continue
if account["last_contacted"] and date.today() - account["last_contacted"] < COOLDOWN:
continue
people = post("/v1/search/company-employees", {
"domain": sig["domain"],
"job_function": "Sales", # pick per topic, values from /v1/search/meta/job_function
"job_level": "VP",
"page": 1,
"page_size": 3,
})["records"]
for p in people:
found = post("/v1/enrich/person/name-domain-to-email", {
"first_name": p["first_name"], "last_name": p["last_name"], "domain": p["company_domain"],
})
if found.get("status") != "found":
continue
sequencer.enroll(SEQUENCE_BY_TOPIC[sig["topic"]], {
"email": found["email"], "first_name": p["first_name"],
"title": p["job_title"], "company": p["company_name"], "topic": sig["topic"],
})
db.log_trigger(sig, len(people))
db, crm and sequencer stand in for your own database and your CRM’s and sequencer’s APIs. If you’d rather build this in a table than a script, the same calls work from Clay with an HTTP API column.
Write the message from the topic, not the signal
Don’t open with "I saw you’re researching sales engagement tools." It tells the buyer they’re being watched, and it’s the line every other vendor using intent data sends too. Use the topic to pick the problem you write about, and write as if the subject came up naturally.
| Topic on the trigger | Angle for the first email |
|---|---|
| Sales engagement software | What tends to break when a team moves from a few reps to many on one sending setup |
| Competitor X alternatives | The two questions worth asking before a switch, and how long a migration really takes |
| Outbound reply rates | One change to targeting that moves replies more than copy changes do |
Each email should make sense to someone who never researched anything. If it only works because of the signal, rewrite it.
Guardrails
- Cooldown. Don’t retrigger the same account for a set time after a sequence starts. Thirty days is a starting point.
- Daily cap. Limit how many new accounts enter sequences per day, so one noisy run can’t flood your reps or your sending domains.
- Owner check. Owned accounts go to the owner, never straight into automation.
- Opt-outs. Check your suppression list before every enroll.
- Log every trigger. You can’t measure what you didn’t record.
Measure by trigger type
Tag every enrolled contact with the topic and the trigger type, such as new topic, jump in strength or competitor. After a few weeks, compare reply and meeting rates by tag, and against a control group from the same watch list with no trigger. Drop the triggers that don’t beat the control. To decide which triggered accounts get a rep first, add the score from lead scoring with intent data.
The loop calls the API for every triggered account on every run. B2Benrich is one plan, unlimited API usage for $500 a month with no credits, so a busy day of triggers doesn’t cost more than a quiet one.
Frequently asked questions
- What is signal based selling?
- Signal based selling means timing outreach to changes at an account, such as new research on your category or a competitor, instead of contacting a fixed list on a fixed schedule.
- What is the difference between signal based outbound and regular outbound?
- Regular outbound works through a list in order. Signal based outbound starts a sequence only when an account shows a new or rising signal, and picks the message based on what that signal is about.
- Should I mention the intent signal in my outreach?
- No. Use the topic to choose which problem to write about, and write the message so it makes sense on its own. Telling someone you saw their research makes them feel watched.
- How often should a signal based outbound workflow run?
- Daily is a good default. It reaches accounts while the research is fresh, and a cooldown per account keeps the same company from being triggered again too soon.
- Can I run trigger based outreach in Clay instead of code?
- Yes. Each API call in the loop can be an HTTP API column in a Clay table, with the intent step added in the same way once B2Benrich’s intent endpoints are documented.
Related guides
- Build an in-market account list from intent dataA step-by-step build: define your ICP filters, pull the accounts researching your topics, add the buyers and their emails, and refresh it weekly.
- Lead scoring with intent data: fit, tech stack and timing in one scoreA simple scoring model a GTM engineer can build: firmographic fit, tech-stack fit and intent timing, weighted into one number per account.
- Use B2Benrich in Clay with an HTTP API columnCall the B2Benrich API from a Clay table: set up the HTTP API column, map the request and the response fields, and run it on a whole list.