A company just raised a Series B. Right now, someone there has budget they didn’t have last month.
That’s the whole logic behind funding-triggered outreach, and it works. But I’ve watched teams ruin it by doing the obvious thing: emailing “congrats on the raise!” the morning it’s announced, along with two hundred other vendors.
I did it myself once. More on that later, because the numbers are embarrassing.
So let’s build the version that actually lands. It’s two endpoints, a small state file, and a bit of patience.
What is funding-triggered outreach?
Funding-triggered outreach means contacting a company because it just raised money, timed to when that new budget becomes spendable.
It’s one flavor of a broader idea called a sales trigger event: a public, observable change at a company that suggests they’re suddenly more likely to buy. A new executive. A fresh office lease. A product launch. And the loudest one of all: a new funding round.
The appeal is simple. Instead of guessing which accounts might have budget, you watch for the moment budget visibly arrives. Then you show up with something useful.
📌 Definition: A trigger event is a public change at a company (funding, hiring, leadership, expansion) that signals a new problem or new budget, and a reason to reach out NOW rather than someday.
Why a funding round is the clearest budget signal you can watch
Because it’s real money, publicly announced, with a date on it.
Most buying signals are inferred. Somebody visited your pricing page. Somebody downloaded a whitepaper. Maybe that means something. Maybe an intern was bored.
A funding round is different in three ways:
- It’s verifiable. Rounds leave a paper trail. In the US, companies raising under common exemptions file a Form D with the SEC within 15 days of the first sale. This isn’t gossip; it’s filed paperwork.
- It’s timestamped. You know roughly when the money landed, which means you can reason about when it gets spent.
- It predicts spending. Investors don’t fund companies to sit on cash. A raise comes with growth plans (hiring, tooling, new markets), and every one of those plans is somebody’s purchase decision.
And the round type tells you what kind of spending. A seed round and a Series C create completely different problems inside a company. Investopedia’s breakdown of funding stages is worth ten minutes if the letters blur together for you; we’ll use them later to shape the message.
That’s the theory. One more piece of context, then the build.
Where funding data actually comes from
Funding data flows from a handful of upstream sources, and knowing them explains almost every quirk you’ll hit later.
- Press releases and tech media. The loudest source and usually the first public one. Also the least structured: amounts get rounded, round types get fuzzy.
- Regulatory filings. Form D in the US, similar disclosures elsewhere. Structured and reliable, but they cover only certain raise types, and the filing can land before OR after the press.
- Company announcements. LinkedIn posts, blog updates, investor pages. Accurate but scattered across a million places.
- Aggregator databases. The layer that stitches the first three together into something queryable, which is what a funding data API gives you programmatic access to.
Because the sources publish on different schedules, no two databases agree on the exact date or amount for every round. And that’s fine. Your workflow doesn’t need to-the-day precision; it needs to notice that a round HAPPENED, within a week or so, for a list of accounts you care about.
Manually, that means checking dozens of decision-makers’ announcements, news feeds, and filings every week. This is exactly the kind of repetitive checking an API should do for you. So let’s make it do that.
What you’re building
Watch a list of accounts → detect a new round → filter for rounds that mean budget → find the right person → reach out on YOUR timing, not the news cycle's
Two endpoints do all the work:
- Company Fundraising: rounds, amounts raised, and investor details
- Person Search: finds the person who owns the budget you care about
Everything else is a state file and a cron job. No platform, no subscription to a “signals suite”, no Zapier spaghetti. Let’s get into it.
Step 1: Pull the funding data
from cufinder import Cufinder
client = Cufinder('your-api-key-here')
funding = client.elf('cufinder')
print(funding)The query takes a company name, domain, or LinkedIn URL. What comes back is a small, dense object. The fields you’ll actually use:
- funding_last_round_type: “seed”, “series a”, “series b”, and so on. This drives your messaging later.
- funding_money_raised: the amount as a string, like “us$ 5m”. You’ll parse this in step 3.
- funding_last_round_investors_url: a link to the round’s investor details.
- confidence_level: how sure the match is. Treat anything low with suspicion before a rep acts on it.
That investor field matters more than people realize. Investors have portfolios, and a portfolio is a warm-intro map. If your best customer shares an investor with the company that just raised, you don’t need cold email at all.
One cost note before you loop this over 500 accounts: the fundraising endpoint uses 4 credits per record found. Budget for it, and don’t re-pull companies whose state hasn’t changed, which is exactly what the next step is for.
Step 2: Detect the change, don’t just read the value
Here’s the bit most people skip. A funding API tells you the current state. A trigger needs the DIFFERENCE between last week and this week.
So you have to store what you saw last time:
import json, os
STATE = 'funding_state.json'
def load_state():
return json.load(open(STATE)) if os.path.exists(STATE) else {}
def save_state(state):
json.dump(state, open(STATE, 'w'))
def check_for_new_round(client, company, state):
current = client.elf(company)
previous = state.get(company)
state[company] = current
if previous is None:
return None # first run, nothing to compare
if current != previous:
return current # something moved
return NoneFirst run establishes your baseline and fires zero alerts. That’s correct behaviour, not a bug. Run it once, ignore the output, and start watching from run two.
One alert per new round sounds clean. Reality is messier: not every “change” is a round worth acting on. Here’s the filter that fixes it.
Step 3: Filter for rounds that actually mean budget
Not every round is a buying signal. A small bridge round (a short-term top-up between proper rounds) usually means the company is stretching runway, not opening its wallet. Alerting your reps on those burns trust in the whole system.
So parse the amount and gate on it:
import re
ROUNDS_THAT_MATTER = {'series a', 'series b', 'series c'}
def parse_millions(raised):
"""'us$ 5m' -> 5.0, 'us$ 1.2b' -> 1200.0, None if unparseable."""
m = re.search(r'([\d.]+)\s*([mb])', (raised or '').lower())
if not m:
return None
value = float(m.group(1))
return value * 1000 if m.group(2) == 'b' else value
def is_real_signal(funding, min_millions=5):
info = funding.get('data', {}).get('fundraising_info', {})
round_type = (info.get('funding_last_round_type') or '').lower()
amount = parse_millions(info.get('funding_money_raised'))
if round_type not in ROUNDS_THAT_MATTER:
return False
if amount is None or amount < min_millions:
return False
return TrueTune the threshold to your deal size. If you sell a $200/month tool, a $3M seed is a fine trigger. If you sell six-figure contracts, you probably want Series B and up.
And what about the big letters? People ask if a Series D is a red flag; it isn’t by itself. Later rounds just mean a different buyer: more process, more stakeholders, more security review. Still budget. Different conversation.
💡 Tip: Bridge rounds and small extensions rarely mean new budget. Filter on amount and round type BEFORE you alert a rep; one bad alert costs you more credibility than ten good ones earn.
Step 4: Find who to actually contact
So who actually gets the money? New budget goes to different people depending on what you sell. Don’t default to the CEO.
Person Search filters people by role and seniority; the documented parameters are job_title_role (sales, engineering, marketing, operations, finance and so on) and job_title_level (cxo, vp, director, manager and the rest). Map what you sell to who owns that budget:
ROLE_MAP = {
'devtools': [('engineering', 'vp'), ('engineering', 'cxo'), ('engineering', 'director')],
'marketing': [('marketing', 'vp'), ('marketing', 'cxo'), ('marketing', 'director')],
'sales': [('sales', 'vp'), ('sales', 'cxo'), ('sales', 'director')],
}
def find_buyer(client, domain, country, category):
for role, level in ROLE_MAP[category]:
result = client.pse(
country=country,
company_domain=domain,
job_title_role=role,
job_title_level=level
)
people = (result.get('data', {}) or {}).get('peoples') or []
if people:
return people[0]
return NoneWhy VP first? Because after a raise, companies hire. The VP who just got headcount approved is a far better conversation than the CEO who’s fielding congratulations all week. Person search costs 5 credits per record found, so the early-exit loop above stops as soon as it lands a match.
That’s the data. Now wire it together.
The full watcher
import time
from cufinder import Cufinder
client = Cufinder('your-api-key-here')
def run_watch(accounts, category='sales'):
state = load_state()
alerts = []
for acct in accounts:
try:
moved = check_for_new_round(client, acct['company'], state)
except Exception as e:
print(f"funding check failed for {acct['company']}: {e}")
continue
if moved and is_real_signal(moved):
buyer = find_buyer(client, acct['domain'],
acct.get('country', 'US'), category)
alerts.append({'company': acct['company'],
'funding': moved,
'contact': buyer})
time.sleep(0.7)
save_state(state)
return alertsRun it weekly on a cron. Daily is overkill: funding rounds don’t move that fast, and you’ll just burn credits confirming nothing changed.
The time.sleep(0.7) keeps you inside the API’s usage limits: 100 requests per minute per key on a fixed 60-second window. A weekly pass over a few thousand accounts fits comfortably if you spread it out instead of firing everything at once.
When to actually send (the part everyone gets wrong)
Do NOT email on announcement day. That inbox is a warzone.
Think about what announcement day looks like from the inside. Press interviews. Investor congratulations. Recruiters. Agencies. And two hundred vendors who all set up the same Google Alert, all opening with the same line: “Saw the news, congrats on the raise!”
Your beautifully timed email is indistinguishable from the noise. Deleted in a batch of forty.
Wait two to three weeks instead. By then:
- The congratulations flood has dried up.
- The money has actually landed in the account.
- The growth plans in the pitch deck have turned into real headcount requests and real tooling decisions.
Your message arrives while they’re doing the work instead of doing the press. That’s the entire edge, and almost nobody takes it because waiting feels like losing.
🧠 Rule of thumb: Detect on day 0, send on day 15-20. The announcement is the starting gun for your TIMER, not for your email.
One more thing before you write a word: check the contact is still the contact. B2B contact data decays at roughly 22.5% a year according to HubSpot’s database decay research, and it decays fastest at companies that just raised, because that’s exactly when people get promoted, poached, and hired. Re-run the person lookup on send day, not detection day.
Stale data isn’t a cosmetic problem, either. It has a price tag:
“Every year, poor data quality costs organizations an average of $12.9 million.”
A funding-triggered email to a VP who left last month doesn’t just miss. It advertises that your data is old, to the exact account you were trying to impress with your timing.
Match the message to the round stage
And don’t lead with the funding. Lead with the problem the funding creates. Which problem that is depends on the stage:
- Seed: Founder-led everything. Tiny budgets, fast decisions. The problem is doing anything repeatable at all. Sell speed and simplicity, or stay away until Series A.
- Series A: First real go-to-market build-out. First ops hires, first proper stack. The problem is turning founder hustle into a process. This is the sweet spot for most B2B tools.
- Series B: Scaling what works. Teams double, and the systems that held at 30 people crack at 90. The problem is growth breaking things. If you sell infrastructure, data, or anything with “at scale” in the pitch, this is your round.
- Series C and later: Consolidation and expansion. New regions, security reviews, procurement processes. The problem is complexity. Longer cycles, bigger contracts, more stakeholders.
Turn it into a formula your reps can actually follow:
→ Round stage → what just changed inside the company → the problem you open with Series B → sales team doubling this year → "how are you keeping data quality up while onboarding 20 reps?"
Notice what’s missing: any mention of the round itself. They know they raised. Everyone in their inbox knows they raised. The one email that skips the congratulations and names the actual problem reads like it came from someone paying attention.
Three opening lines that don’t say congrats
Want to know what the graveyard looks like? It looks like this:
“Congrats on the Series B! I’d love to show you how we help fast-growing companies…”
Deleted. Every time. Not because it’s rude, but because it’s the two-hundredth copy of itself.
Here’s the shape that works instead. Each one names a downstream consequence of the raise without mentioning the raise:
- The scaling question: “Most sales teams that double headcount in a year watch their CRM data quality fall off a cliff around month four. Curious how you’re planning around that?”
- The peer observation: “When [similar company] went from 30 to 90 people, the onboarding process was the first thing that broke. Is that on your radar for this year?”
- The specific compliment: “Saw you’re opening the Amsterdam office. That usually means someone inherits a very messy territory-routing problem. Happy to share how two other teams handled it.”
Each of these proves you did homework the other two hundred vendors didn’t do. And each gives the decision-maker something to react to besides “thanks.”
One workflow, one problem, one question. That’s the email.
Layer funding on top of other signals
Funding alone is good. Funding plus corroboration is much better. Because trigger events compound: each independent signal pointing the same way multiplies your confidence that this account is in a genuine growth phase, not just a news cycle.
Think about what a raise sets in motion over the following two quarters. Hiring sprees. New executives. Office openings. Each one is its own trigger event, and each one names a different decision-maker with a different fresh problem. A single funding alert, watched patiently, often turns into three or four distinct outreach moments: to different people, about different things.
The strongest compound trigger I know: a company that raised in the last quarter AND is now hiring for the exact team you sell to. The raise says budget exists. The hiring says the budget is being spent on the problem you solve. I walked through the hiring half in the hiring signals workflow; the two watchers share the same state-file pattern, so combining them is an afternoon of work.
If you’d rather consume the detection ready-made instead of diffing state yourself, there’s also a dedicated funding-round-announced signal in the Buying Signals docs that fires when a new round is detected, alongside sibling signals for hiring, headcount, and leadership changes.
Either way, the rule is an AND-gate:
raised in last 90 days AND (hiring for your buyer's team OR new exec in your category) → top of the call list
Measure it like a channel, not a hack
Funding-triggered outreach is a channel. Channels get measured. And because the volume is low, the measurement is genuinely easy; you can track it in a spreadsheet with four columns:
- Alert precision: of the alerts that fired, how many were rounds a rep agreed were real signals? Below 80%, tighten your amount filter.
- Reply rate per alert: triggered sends should beat your cold baseline by a wide margin. If they don’t, your timing or your message is off, usually the message.
- Meetings per quarter: the number that matters. Even a handful justifies a workflow this cheap to run.
- Time from detection to send: if this drops under a week, someone on the team is getting impatient and sending into the announcement noise again.
Review the four numbers monthly. Growth in meetings with stable precision means you can widen the watchlist. Falling reply rates with rising send volume means the team has quietly turned your sniper rifle back into a shotgun.
Now, the failure modes, because every watcher I’ve ever run has hit at least two of these.
What breaks
Funding data lags the announcement. No provider is instant, including ours. Filings, press, and databases all update on their own schedules. If your entire play depends on being first, this isn’t the right signal for you. But as I said, being first is usually the wrong goal anyway. The two-week wait makes a few days of lag irrelevant.
Your state file drifts. If you change how you store the response, every account will look like it moved and you’ll get a wall of false alerts. Version your state format before you change it, and treat a 100%-alert run as a bug, not a jackpot.
The same round fires twice. Rounds get re-reported: an amount gets corrected, an investor list gets updated, and the record changes without a new round existing. If the round type hasn’t changed, treat it as an update, not a trigger. Keying alerts on funding_last_round_type transitions kills most duplicates.
Currency strings vary. “us$ 5m” parses cleanly. Other currencies and formats exist. That’s why parse_millions() returns None instead of crashing, and why unparseable amounts should go to a human, not to the trash.
Small raises aren’t signals. Covered in step 3, but it’s the failure mode I’ve seen most: a tiny extension round rarely means new budget. Filter on amount before you alert anyone.
What this looked like the first time I ran it
I’ll be honest about my own scoreboard here, because I made the exact mistake this article warns about.
In 2023 a Berlin fintech on my target list announced its Series B. I had the email drafted within the hour (“Huge congrats on the raise!”) and sent versions of it to about 250 contacts across similar accounts that week. Two replies. Both polite versions of no. That’s a 0.8% reply rate for a week of work, and honestly, I earned it.
The next quarter I rebuilt the whole thing as a watcher over 61 named accounts. Weekly runs. Amount filter at $5M. Fifteen to twenty days of deliberate waiting per alert, then one email that led with a scaling problem, not the round.
→ 61 accounts watched → 9 qualifying rounds in the quarter → 9 emails sent → 4 meetings booked
Nine emails. Four meetings. Against 250 emails and zero meetings the quarter before. Fewer, later, better: that’s the entire lesson, and it took me an embarrassing amount of spray-and-pray to learn it.
How this guide was put together
The method names, parameters, response fields, credit costs (4 per record for fundraising, 5 per record for person search), and the 100-requests-per-minute fixed-window limit all come straight from the live API documentation, checked in August 2026. Workflow numbers come from my own runs, and your ratios will differ. External claims are linked to their sources: the SEC, Investopedia, HubSpot, and data-quality research from Gartner and Harvard Business Review, both of which put real dollar figures on what messy account data quietly costs. And one honest limitation, stated plainly: every funding data source lags the announcement by some amount, including ours. Build for it.
Frequently asked questions
How often should the watcher run?
Weekly for most teams. Funding rounds are infrequent enough that daily checks mostly cost credits to learn nothing changed. Weekly detection plus the two-to-three-week send delay still puts you in the inbox well inside the budget-allocation window.
Can I watch companies I don’t have domains for?
The funding call takes a company name, so yes. But you’ll want the domain for the person lookup, so resolve it once up front with Company Name to Domain and store it in your accounts file.
How many accounts can I watch?
At 100 requests per minute, a weekly run over a few thousand accounts is comfortable. Spread it across the hour rather than firing everything at once, and remember the credit math: 4 credits per fundraising record found, so a 2,000-account watchlist has a real monthly cost.
What is a trigger event in business?
A trigger event is a public change at a company that creates a reason to contact them right now: a funding round, a leadership hire, an expansion, a product launch. The change usually comes with new problems and new budget, which is why timing outreach to triggers beats contacting the same company on a random Tuesday.
What are the triggers in sales?
The common ones: funding rounds, executive hires, job-posting surges, product launches, office openings, layoffs, leadership departures, and technology changes. Funding and hiring are the most watchable by API because both leave public, timestamped records you can diff week over week.
Is Series D funding a red flag?
No: a Series D just means a later-stage company raising more capital, though context matters. A flat or down round can signal trouble; a strong Series D usually signals expansion. For outreach, later rounds mean bigger budgets with slower, more formal buying processes. Adjust your expectations, not your filter.
Is an oversubscribed funding round a good signal?
Generally yes. Oversubscribed means more investors wanted in than the company had room for, which suggests strong momentum. For your workflow it changes little (the round type and amount still drive the play), but it’s a useful line of context for the rep making the call.
Start with 50 accounts
Pick fifty companies you’d genuinely like to work with. Run the watcher for a month and see how many actually move.
It won’t be many, and that’s the point. A handful of well-timed conversations beats a blast to two thousand people who aren’t ready. That’s the trade this whole workflow is making for you.
Funding-triggered outreach isn’t a growth hack. It’s just paying attention, automated. The API watches the accounts, the filter guards your credibility, the timer guards your timing, and you show up as the one vendor who noticed the problem instead of the press release.
And when the first alert fires? Set the timer. Fifteen days. You’ve got this.
Bad
Okay
Good
Amazing
