Find high-intent leads

$ Set up https://jell.run/SKILL.md, then find companies hiring "lifecycle marketing manager" in the US in the last 30 days and get me a verified email for the VP Marketing at each one.

Most lead lists are a filter over a static database: title, headcount, industry. Everyone buying from the same database gets the same list, and the list has no opinion about when to reach out. Intent changes that. A company that just posted three roles on the team you sell to, or closed a round last month, or swapped out the tool you replace, is a different prospect from an identical company that did none of those things.

This guide builds that list with four calls: find the companies acting, find the person who owns the problem, get their email, verify it before you send.

The pipeline

company.jobs      →  companies hiring for the role that implies your problem
people.search     →  the decision maker at each of those companies
contact.find      →  their work email
contact.verify    →  deliverability, before it touches your sender reputation

Four capabilities, one key, one prepaid balance. Roughly two cents per finished, verified contact at the starting prices, and the calls that find nothing are released rather than billed.

Step 1: find the signal, not the company

Hiring is the cheapest honest intent signal there is. A job posting is a public statement that a company has budget, a gap, and a hiring manager who already admitted the gap exists in writing.

Search postings by title and location rather than by company, and you get the account list as a side effect:

curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{
    "capability": "company.jobs",
    "input": {
      "query": "lifecycle marketing manager",
      "location": "United States",
      "posted_within": "30d",
      "limit": 50
    }
  }'

Each posting carries the company, the title, the location and the date. Sorted by date, that is a queue of accounts that declared a need in the last thirty days.

Two other signals stack on top when you want a tighter list:

• company.funding returns rounds, amounts, dates and investors for a domain. A round closed inside 90 days means budget that has to be spent.
• company.technologies returns the detected stack. If you replace a tool, the accounts running it are your list; if you integrate with one, the accounts running it are your easiest sale.

Run these against the domains that came back from company.jobs and score the result. A company hiring for the role, funded this quarter, and running the tool you replace is not a cold lead.

Step 2: find the person who owns the problem

The hiring manager is rarely the buyer. people.search takes filters rather than a name, so you can ask for the seniority band that actually signs:

curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{
    "capability": "people.search",
    "input": {
      "titles": ["VP Marketing", "Head of Growth", "Director of Demand Generation"],
      "seniority": ["vp", "director"],
      "companies": ["acme.com", "globex.com"],
      "company_headcount": "51-200",
      "limit": 25
    }
  }'

Pass the domains you collected in step 1 as companies and the search stays scoped to accounts that showed intent. Without that scope you are back to buying a database.

Step 3: get the email

contact.find takes a first name, a last name and a company domain, and returns the work email with a status:

curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -H "Idempotency-Key: lead-acme-rivera-1" \
  -d '{
    "capability": "contact.find",
    "input": {"first_name": "Alex", "last_name": "Rivera", "company_domain": "acme.com"},
    "routing": {"strategy": "best_value", "max_cost": "0.05"}
  }'

Six providers sit behind this capability. Auto routing tries them in order and only the one that delivers is charged. A lookup that finds nothing is an unbilled no-match: the reservation is released in full, so a list with a 60% hit rate costs you 60% of a list, not 100%.

Set Idempotency-Key per contact. Re-running the same list after a crash then costs nothing for the rows you already have.

Step 4: verify before you send

A found email is a guess until it is verified. Sending to invalid addresses is how a sending domain gets throttled, and the damage outlives the campaign.

curl -X POST https://api.jell.run/v1/run \
  -H "Authorization: Bearer $JELL_API_KEY" \
  -d '{"capability": "contact.verify", "input": {"email": "[email protected]"}}'

The response separates valid, invalid and unknown, and flags catch_all domains where the server accepts everything and tells you nothing. Send to valid. Hold unknown and catch_all for a channel that does not burn reputation, or send them at a much lower volume from a separate domain.

What this replaces

The fragmented version of this pipeline is four vendor accounts, four auth schemes, four response shapes, four minimum commitments, and glue code that breaks when any one of them ships a change. Most of those contracts are annual and per-seat, which is the wrong shape entirely when the consumer is an agent that runs in bursts.

Here it is one key and one balance. Every run returns the provider it used, the reason it picked that provider, the latency and the exact charge, so the cost of a list is a number you can read rather than an invoice you reconcile.

Where it breaks

• Hiring signals lag. A posting is 1 to 30 days behind the decision to hire. Use posted_within to keep the queue fresh, and treat anything older than 60 days as a cold account again.
• Catch-all domains are common in enterprise. Verification returns unknown honestly instead of guessing. Do not let a scoring model treat unknown as invalid.
• people.search filters are only as good as public profile data. Titles drift, and a "Head of Growth" at 30 people is a different buyer from one at 3,000. Keep company_headcount in the filter.
• Volume caps deliverability, not the other way around. This pipeline can build a list far faster than a new sending domain can safely send to it. Warm the domain first: see the email domain health check in the outbound guides.

Run it as an agent

The same loop from a coding agent, with no code to write:

jell discover -q "companies hiring for a role, then the decision maker's verified email"
jell run -c company.jobs -i '{"query":"lifecycle marketing manager","posted_within":"30d"}'
jell run -c contact.find -i '{"first_name":"Alex","last_name":"Rivera","company_domain":"acme.com"}'

Install the agent skill once and an agent discovers these capabilities on its own, checks the price with /v1/inspect before spending, and reads the balance back over the same API.

What does each call cost?#

Prices below are the starting price per successful call. /v1/inspect returns the exact figure before the run and reserves it against your balance; failures and unbilled no-matches release the hold in full.

One prepaid balance covers every row. Capabilities marked coming soon are listed but not yet executable.

FAQ#

What makes a hiring signal better than firmographic fit?

Fit tells you a company resembles your customers. It does not change over time, so it cannot tell you when to reach out. A job posting is dated, specific and public: the company wrote down that it has a gap, has approved headcount, and named the function. That converts a static list into a queue ordered by recency, which is the only ordering a rep can act on.

How fresh does a signal need to be?

Under 30 days for hiring, under 90 for funding. Past that the decision the signal pointed at has usually been made, and outreach referencing it reads as late rather than informed. Use posted_within on company.jobs to keep the queue honest, and re-score rather than letting old signals sit at their original weight.

Why verify emails if the finder already returned one?

Because a found address is an inference, not a confirmation. Providers construct and match patterns, and a plausible address that bounces damages the sending domain for every later campaign. Verification separates valid from invalid and, importantly, flags catch_all domains where no verifier can tell you anything. That third state needs its own handling rather than being forced into the first two.

Does this work outside North America and Western Europe?

Less well, and honestly so. Job posting coverage, professional profile data and email finding all degrade where fewer companies publish publicly. The pipeline still runs, but expect materially lower hit rates and budget for a phone-first or social-first motion in those markets instead.

What does a finished contact actually cost?

Around two cents at the starting prices, dominated by the contact lookup and the verification. The two calls that build the account list are cheaper per row because one job search returns many companies. Misses are released rather than billed, so the effective cost per finished row is close to the list price divided by your hit rate, not multiplied by your attempts.

How can I detect hiring signals or job postings at a target company via API?

company.jobs returns the postings for a company domain, or every company hiring a given title in a location, with posting dates. That is the hiring signal without integrating Greenhouse, Lever and Ashby job boards one by one. From the account, people.search finds the person who owns the budget and contact.find gets a verified work email.

How can I search for people by job title and company with an API and pay per result?

people.search takes title, seniority, company headcount, location and industry filters and returns LinkedIn profiles with current role and company. It is priced per result at the limit you request, with no monthly subscription, and the quote comes back from /v1/inspect before the run. Enrich the results with contact.find next; a miss there is not billed.