How to Build an Agentic Prospecting Tool with Claude

To build an AI prospecting tool, you put Claude between the user’s sentence and a people and company data API such as Crustdata, Apollo’s People API or Explorium.

Published

Written by

Chris Pisarski

Reviewed by

Manmohit Grewal

Read time

22

minutes

From a sentence to a prospect list: the user asks, Claude fills a tool schema, values are checked with Autocomplete, then search and enrich only the people you keep. In our test, 62 founders cost 49.17 credits to find.

I’m on the Crustdata team, and we built this flow ourselves, then compared it with how other teams do it. Over the past six months we've talked with an AI sales platform and an outbound platform for founders based in that put natural-language prospecting in front of their own customers. They were building for different users, but they hit the same wall.

Claude wasn’t the hard part. The tool schema, the query plan and what the product does when a search comes back thin were.

To build an AI prospecting tool, you put Claude between the user's sentence and a people and company data API such as Crustdata, Apollo's People API or Explorium. Claude turns "seed-stage B2B AI SaaS founders in London, 2 to 10 employees" into structured filters. Your code checks them, runs the search and returns a list the user can read and edit. The people they keep get enriched and handed to a campaign.

That’s the whole shape. The rest of this guide is the part that takes the time.

We wrote it for teams shipping natural-language prospecting to their own customers, like AI sales platforms and outbound tools. If you’re building the same thing for your own reps, a short note in each section says where it differs. It draws on those conversations and on a paid test we ran on October 21, 2026. In that test, one sentence became 80 matching companies and 62 founders (one per company), and the whole run, searches plus enriching 10 of them, cost 72.67 credits at public list prices.

Crustdata credits cost $0.30 to $0.01 per credit, lower depending on plan. You can try the search, Autocomplete and person enrich calls in this guide on a free Crustdata account, which comes with 100 credits. Contact enrichment needs an enterprise plan.

If what you are building is the outbound agent that writes and sends the emails, our guide to building an AI SDR on reliable data infrastructure covers that side.

The build at a glance

Here’s the whole flow in eight steps. The rest of the guide takes each one in turn.

  • Pick your day-one filters. Title, seniority, company, industry, size, location, funding stage, plus a way to exclude people you already have. Users will compare you with the panels they know.

  • Let Claude fill in a tool schema. One tool, one field per filter, plus a follow-up question field. Claude handles the language, and your code handles the plan.

  • Check every value with Autocomplete. It’s free, and it catches values the database doesn’t store, like “SaaS” as an industry, before you spend a credit.

  • Choose people-first or company-first. If the request includes funding stage, revenue or a company category, search companies first, then find the people at them.

  • Ask before searching when the request is too broad. One follow-up question beats a hundred paid calls.

  • Make the results earn trust. Show the filters Claude applied, explain empty results, show the count first, and never guess a blank.

  • Enrich only the people the user keeps. Then hand them to a campaign, and watch them for job changes so sequences stop when someone moves.

  • Test, cap and pilot. Run a regression set of real sentences, cap credits per customer, and ship to one group of users before everyone.

Start this week:

  • Collect 30 sentences your users (or reps) have typed or would type.

  • Write down the filters each sentence should produce.

  • Prototype the parser in Claude with a data connector (Step 5 below).

  • Run the 30 sentences and record the four numbers in the testing section.

Who this is for:

  • Building for your customers: read straight through.

  • Building for your own sales team: read the notes marked "If you are building this for your own team" and the section on own-team builds.

Which filters do buyers expect on day one?

The ones they already know from people databases: job title, seniority, company, industry, company size, location and funding stage, plus a way to leave out people they already have. Apollo's People API, for example, filters on job titles, seniorities, locations and company headcount ranges, and your users will compare your tool with panels like that on their first search, so the parser has to produce every filter from a sentence.

People search is where this usually breaks. The AI sales platform we spoke with had an account search that worked and a people search that didn’t. Its product lead put it in one line: “my customers are struggling to find people and find companies.” The people results were missing titles and employers.

The filters below decide whether a people search feels complete.

Filter

Where it lives in Crustdata

Example values

How to get valid values

Job title

Person search, experience.employment_details.current.title

"Founder", "Founder & CEO", "VP Sales"

Person Autocomplete, free

Seniority

Person search, ...current.seniority_level

"CXO", "Owner / Partner", "Director"

Person Autocomplete, free

Employer

Person search, ...current.company_id

IDs from a company search

Company search first

Employer industry

Person search, ...current.company_industries

"Artificial Intelligence", "Software Development"

Person Autocomplete, free

Employer size

Person search, ...current.company_headcount_range

"2-10", "11-50"

Person Autocomplete, free

Person's location

Person search, basic_profile.location.city or .country

"London", "United Kingdom"

Person Autocomplete, free

Funding stage

Company search only, funding.last_round_type

"seed", "pre_seed"

Company Autocomplete, free

Business model or category

Company search, taxonomy.categories

"SaaS", "Artificial Intelligence"

Company Autocomplete, free

Revenue

Company search only, revenue.estimated.lower_bound_usd

numbers in USD

n/a

Leave out people you have

Your own code, on crustdata_person_id

IDs you already hold

n/a

Two things bit us in the test. “SaaS” is stored as a company category, not an industry, so a parser that maps it to an industry gets zero people back. And the funding stage lives only in company search. A person searching with a funding filter returned HTTP 400, “Unsupported filter field.”

Checking each value against Autocomplete before searching catches both. It’s free, and it returns the stored values a filter expects.

If you are building this for your own team: junior reps often prefer picking from fields to typing a sentence. One sales team we spoke with, building an internal list tool for its reps, wanted exactly that : a plain criteria picker that produced a list. Show the same filters as editable fields, offer saved template searches for the segments your team works most, and make a few fields required before a search runs.

How does Claude turn a sentence into a query plan?

Claude reads the sentence and fills in a tool schema you define. Your code then checks every value, decides which searches to run in which order, and calls the data API.

Claude handles the language and your code handles the plan, and keeping those two jobs apart is what lets you test, cap and explain each search.

Step 1: Define the tool Claude fills in

Give Claude one tool whose fields are your day-one filters. With Claude's tool use, Claude returns a tool_use block with the arguments, and the strict setting keeps those arguments matching your schema exactly. We added a field for a follow-up question, so Claude can ask instead of guessing.

import anthropic

client = anthropic.Anthropic()

PLAN_TOOL = {
    "name": "plan_prospect_search",
    "description": (
        "Turn the user's request into prospect search filters. "
        "Use only values the user stated. If the location is only a region, "
        "or no job title or seniority is given, fill ask_user with one short question."
    ),
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {
            "titles": {"type": "array", "items": {"type": "string"}},
            "seniority_levels": {"type": "array", "items": {"type": "string"}},
            "person_city": {"type": "string"},
            "person_country": {"type": "string"},
            "employer_industries": {"type": "array", "items": {"type": "string"}},
            "company_categories": {"type": "array", "items": {"type": "string"}},
            "employer_size_ranges": {"type": "array", "items": {"type": "string"}},
            "funding_rounds": {"type": "array", "items": {"type": "string"}},
            "one_per_company": {"type": "boolean"},
            "ask_user": {"type": "string"},
        },
        "required": [
            "titles", "seniority_levels", "person_city", "person_country",
            "employer_industries", "company_categories", "employer_size_ranges",
            "funding_rounds", "one_per_company", "ask_user",
        ],
        "additionalProperties": False,
    },
}

def plan_search(user_sentence: str) -> dict:
    response = client.messages.create(
        model="claude-opus-5-5",
        max_tokens=4000,
        tools=[PLAN_TOOL],
        tool_choice={"type": "auto"},
        system="Always answer by calling plan_prospect_search. Leave a field empty when the user did not mention it.",
        messages=[{"role": "user", "content": user_sentence}],
    )
    for block in response.content:
        if block.type == "tool_use" and block.name == "plan_prospect_search":
            return block.input
    raise ValueError("Claude did not return a search plan")
import anthropic

client = anthropic.Anthropic()

PLAN_TOOL = {
    "name": "plan_prospect_search",
    "description": (
        "Turn the user's request into prospect search filters. "
        "Use only values the user stated. If the location is only a region, "
        "or no job title or seniority is given, fill ask_user with one short question."
    ),
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {
            "titles": {"type": "array", "items": {"type": "string"}},
            "seniority_levels": {"type": "array", "items": {"type": "string"}},
            "person_city": {"type": "string"},
            "person_country": {"type": "string"},
            "employer_industries": {"type": "array", "items": {"type": "string"}},
            "company_categories": {"type": "array", "items": {"type": "string"}},
            "employer_size_ranges": {"type": "array", "items": {"type": "string"}},
            "funding_rounds": {"type": "array", "items": {"type": "string"}},
            "one_per_company": {"type": "boolean"},
            "ask_user": {"type": "string"},
        },
        "required": [
            "titles", "seniority_levels", "person_city", "person_country",
            "employer_industries", "company_categories", "employer_size_ranges",
            "funding_rounds", "one_per_company", "ask_user",
        ],
        "additionalProperties": False,
    },
}

def plan_search(user_sentence: str) -> dict:
    response = client.messages.create(
        model="claude-opus-5-5",
        max_tokens=4000,
        tools=[PLAN_TOOL],
        tool_choice={"type": "auto"},
        system="Always answer by calling plan_prospect_search. Leave a field empty when the user did not mention it.",
        messages=[{"role": "user", "content": user_sentence}],
    )
    for block in response.content:
        if block.type == "tool_use" and block.name == "plan_prospect_search":
            return block.input
    raise ValueError("Claude did not return a search plan")
import anthropic

client = anthropic.Anthropic()

PLAN_TOOL = {
    "name": "plan_prospect_search",
    "description": (
        "Turn the user's request into prospect search filters. "
        "Use only values the user stated. If the location is only a region, "
        "or no job title or seniority is given, fill ask_user with one short question."
    ),
    "strict": True,
    "input_schema": {
        "type": "object",
        "properties": {
            "titles": {"type": "array", "items": {"type": "string"}},
            "seniority_levels": {"type": "array", "items": {"type": "string"}},
            "person_city": {"type": "string"},
            "person_country": {"type": "string"},
            "employer_industries": {"type": "array", "items": {"type": "string"}},
            "company_categories": {"type": "array", "items": {"type": "string"}},
            "employer_size_ranges": {"type": "array", "items": {"type": "string"}},
            "funding_rounds": {"type": "array", "items": {"type": "string"}},
            "one_per_company": {"type": "boolean"},
            "ask_user": {"type": "string"},
        },
        "required": [
            "titles", "seniority_levels", "person_city", "person_country",
            "employer_industries", "company_categories", "employer_size_ranges",
            "funding_rounds", "one_per_company", "ask_user",
        ],
        "additionalProperties": False,
    },
}

def plan_search(user_sentence: str) -> dict:
    response = client.messages.create(
        model="claude-opus-5-5",
        max_tokens=4000,
        tools=[PLAN_TOOL],
        tool_choice={"type": "auto"},
        system="Always answer by calling plan_prospect_search. Leave a field empty when the user did not mention it.",
        messages=[{"role": "user", "content": user_sentence}],
    )
    for block in response.content:
        if block.type == "tool_use" and block.name == "plan_prospect_search":
            return block.input
    raise ValueError("Claude did not return a search plan")

For "seed-stage B2B AI SaaS founders in London, 2 to 10 employees", the plan should come back with founder as the title and London as the city. It should also set AI and SaaS as company categories, "2-10" as the size range, seed and pre-seed as the funding rounds, and one person per company.

"B2B" has no filter of its own in this set, so it stays out of the plan and your UI can say so rather than pretend.

Step 2: Check every value before you spend a credit

Send each value to Autocomplete and swap in the stored value it returns. If nothing comes back, drop the value and tell the user. Autocomplete is free, so this costs nothing and catches values the database doesn’t store, like “SaaS” as an industry, before any paid call.

Mapping a request onto filters is where the edge cases live. The founder platform’s CEO had already pulled the full industry list to map against, and still described it as “a ton of edge cases.” I believe him.

import requests

API = "https://api.crustdata.com"
HEADERS = {
    "authorization": "Bearer YOUR_API_KEY",
    "content-type": "application/json",
    "x-api-version": "2025-11-01",
}

def resolve(scope: str, field: str, value: str) -> str | None:
    """Return the stored value Autocomplete suggests first, or None."""
    resp = requests.post(
        f"{API}/{scope}/search/autocomplete",
        headers=HEADERS,
        json={"field": field, "query": value, "limit": 5},
    )
    suggestions = resp.json().get("suggestions", [])
    return suggestions[0]["value"] if suggestions else None

# "SaaS" resolves as a company category, and returns nothing as an industry
resolve("company", "taxonomy.categories", "saas")    # "SaaS"
resolve("company", "basic_info.industries", "saas")  # None
import requests

API = "https://api.crustdata.com"
HEADERS = {
    "authorization": "Bearer YOUR_API_KEY",
    "content-type": "application/json",
    "x-api-version": "2025-11-01",
}

def resolve(scope: str, field: str, value: str) -> str | None:
    """Return the stored value Autocomplete suggests first, or None."""
    resp = requests.post(
        f"{API}/{scope}/search/autocomplete",
        headers=HEADERS,
        json={"field": field, "query": value, "limit": 5},
    )
    suggestions = resp.json().get("suggestions", [])
    return suggestions[0]["value"] if suggestions else None

# "SaaS" resolves as a company category, and returns nothing as an industry
resolve("company", "taxonomy.categories", "saas")    # "SaaS"
resolve("company", "basic_info.industries", "saas")  # None
import requests

API = "https://api.crustdata.com"
HEADERS = {
    "authorization": "Bearer YOUR_API_KEY",
    "content-type": "application/json",
    "x-api-version": "2025-11-01",
}

def resolve(scope: str, field: str, value: str) -> str | None:
    """Return the stored value Autocomplete suggests first, or None."""
    resp = requests.post(
        f"{API}/{scope}/search/autocomplete",
        headers=HEADERS,
        json={"field": field, "query": value, "limit": 5},
    )
    suggestions = resp.json().get("suggestions", [])
    return suggestions[0]["value"] if suggestions else None

# "SaaS" resolves as a company category, and returns nothing as an industry
resolve("company", "taxonomy.categories", "saas")    # "SaaS"
resolve("company", "basic_info.industries", "saas")  # None

Step 3: Expect these misfires

We ran the London sentence and the variations in the table below against Crustdata on October 21, 2026. The first four rows each changed one filter and kept the rest fixed, so the difference comes from that filter alone. The funding row is a single request the API rejects.

What the user said

What a naive parser does

What we measured

Fix

"founders"

Title contains "founder"

99 people at 62 of the 80 matching companies. Adding "CEO" and the "Owner / Partner" and "CXO" seniority levels found 146 people at 79 companies.

Search title or seniority, then rank founders first

"2 to 10 employees"

Numeric headcount only

The "2-10" range gave 80 companies, a headcount of 2 to 10 gave 79, and no size filter gave 165

Either works. Use the stored range so it matches person search.

"London"

City equals London

City London 3,593 founders. Location contains "London" 4,062. United Kingdom 10,155. Employer HQ in London 3,953.

Ask whether they mean where the person lives or where the company is

"AI SaaS"

Industry equals "SaaS"

0 people. The API named this filter as the cause, with 48,457 matches without it.

Map "SaaS" to the company category

"seed-stage"

Funding filter on person search

HTTP 400, unsupported field

Run company search first

The London row hides a second trap. In the company-first run, every company had its headquarters in London. But the founders’ own locations read “London, England,” “London Area,” “Greater London” and “United Kingdom,” and a few were outside the country.

A company based in London does not mean its founder lives there, so the tool should ask which one the user means.

Step 4: Decide people-first or company-first

Run a single person search when every filter lives on the person record. Run a company search first when the request includes funding stage, revenue or a company category.

Person search can filter on the employer's industry, size and headquarters, so "founders at 2 to 10 person AI companies in London" is one call. "Seed-stage" is a company fact, so that plan becomes two calls.

In our test, the company-first plan matched every part of the request that has a filter : 80 seed or pre-seed AI and SaaS companies headquartered in London and then 99 founders at those companies. The people-first version without funding returned 3,593 founders. That’s a much larger pool and it ignores the stage the user asked for.

def run_company_first(plan: dict, limit: int = 100) -> list[dict]:
    # One condition per category, so a company must match all of them (AI and SaaS)
    category_conditions = [
        {"field": "taxonomy.categories", "type": "in", "value": [c]}
        for c in plan["company_categories"]
    ]
    company_filters = {"op": "and", "conditions": category_conditions + [
        {"field": "funding.last_round_type", "type": "in", "value": plan["funding_rounds"]},
        {"field": "basic_info.employee_count_range", "type": "in", "value": plan["employer_size_ranges"]},
        # HQ city, used after the user confirms they meant where the company is
        {"field": "locations.headquarters", "type": "(.)", "value": plan["person_city"]},
    ]}
    companies = requests.post(f"{API}/company/search", headers=HEADERS, json={
        "filters": company_filters, "fields": ["basic_info"], "limit": limit,
    }).json()["companies"]
    company_ids = [c["crustdata_company_id"] for c in companies]

    people = requests.post(f"{API}/person/search", headers=HEADERS, json={
        "filters": {"op": "and", "conditions": [
            {"field": "experience.employment_details.current.company_id", "type": "in", "value": company_ids},
            # Widen with seniority levels too, per the misfires table
            {"field": "experience.employment_details.current.title", "type": "(.)", "value": "founder"},
        ]},
        "fields": ["basic_profile", "experience", "social_handles"],
        "limit": limit,
    }).json()["profiles"]

    if plan["one_per_company"]:
        kept, seen = [], set()
        for p in people:
            company_id = p["experience"]["employment_details"]["current"][0]["crustdata_company_id"]
            if company_id not in seen:
                seen.add(company_id)
                kept.append(p)
        people = kept
    return people
def run_company_first(plan: dict, limit: int = 100) -> list[dict]:
    # One condition per category, so a company must match all of them (AI and SaaS)
    category_conditions = [
        {"field": "taxonomy.categories", "type": "in", "value": [c]}
        for c in plan["company_categories"]
    ]
    company_filters = {"op": "and", "conditions": category_conditions + [
        {"field": "funding.last_round_type", "type": "in", "value": plan["funding_rounds"]},
        {"field": "basic_info.employee_count_range", "type": "in", "value": plan["employer_size_ranges"]},
        # HQ city, used after the user confirms they meant where the company is
        {"field": "locations.headquarters", "type": "(.)", "value": plan["person_city"]},
    ]}
    companies = requests.post(f"{API}/company/search", headers=HEADERS, json={
        "filters": company_filters, "fields": ["basic_info"], "limit": limit,
    }).json()["companies"]
    company_ids = [c["crustdata_company_id"] for c in companies]

    people = requests.post(f"{API}/person/search", headers=HEADERS, json={
        "filters": {"op": "and", "conditions": [
            {"field": "experience.employment_details.current.company_id", "type": "in", "value": company_ids},
            # Widen with seniority levels too, per the misfires table
            {"field": "experience.employment_details.current.title", "type": "(.)", "value": "founder"},
        ]},
        "fields": ["basic_profile", "experience", "social_handles"],
        "limit": limit,
    }).json()["profiles"]

    if plan["one_per_company"]:
        kept, seen = [], set()
        for p in people:
            company_id = p["experience"]["employment_details"]["current"][0]["crustdata_company_id"]
            if company_id not in seen:
                seen.add(company_id)
                kept.append(p)
        people = kept
    return people
def run_company_first(plan: dict, limit: int = 100) -> list[dict]:
    # One condition per category, so a company must match all of them (AI and SaaS)
    category_conditions = [
        {"field": "taxonomy.categories", "type": "in", "value": [c]}
        for c in plan["company_categories"]
    ]
    company_filters = {"op": "and", "conditions": category_conditions + [
        {"field": "funding.last_round_type", "type": "in", "value": plan["funding_rounds"]},
        {"field": "basic_info.employee_count_range", "type": "in", "value": plan["employer_size_ranges"]},
        # HQ city, used after the user confirms they meant where the company is
        {"field": "locations.headquarters", "type": "(.)", "value": plan["person_city"]},
    ]}
    companies = requests.post(f"{API}/company/search", headers=HEADERS, json={
        "filters": company_filters, "fields": ["basic_info"], "limit": limit,
    }).json()["companies"]
    company_ids = [c["crustdata_company_id"] for c in companies]

    people = requests.post(f"{API}/person/search", headers=HEADERS, json={
        "filters": {"op": "and", "conditions": [
            {"field": "experience.employment_details.current.company_id", "type": "in", "value": company_ids},
            # Widen with seniority levels too, per the misfires table
            {"field": "experience.employment_details.current.title", "type": "(.)", "value": "founder"},
        ]},
        "fields": ["basic_profile", "experience", "social_handles"],
        "limit": limit,
    }).json()["profiles"]

    if plan["one_per_company"]:
        kept, seen = [], set()
        for p in people:
            company_id = p["experience"]["employment_details"]["current"][0]["crustdata_company_id"]
            if company_id not in seen:
                seen.add(company_id)
                kept.append(p)
        people = kept
    return people

Keeping one person per company happens in your code, and in our run that step took 99 founders down to 62, one for each company that had a founder on record.

Step 5: Ask before you search when the request is too broad

I’d ask one follow-up question before any paid search in three cases:

  • The location is only a region.

  • No title or seniority is given.

  • A 1-result count search shows more than a few thousand matches.

Those thresholds are my suggestion, so tune them on your own test set. Also cap paid calls per chat turn, so an agent can’t run a hundred searches to answer one request.

The founder platform expected broad requests from its users. Its example was founders at seed-stage SaaS companies in Europe, and its CEO’s view was blunt: “Europe is a very broad term so you want to hone in on a city.” He wanted the agent to ask, not search everywhere.

I agree. An agent that answers a broad request by listing every matching company before it looks for people burns credits on companies nobody wanted. One follow-up question and a cap on paid calls prevents that.

Filters or a semantic query: Crustdata's Person Search also accepts the whole sentence as a semantic query (in beta). It can’t check the funding stage, and it took a median of 7.1 seconds across 6 runs. I use it as a slower second pass and keep it out of the chat turn where the user is waiting.

Prototype in Claude first: Adding Crustdata's MCP server to a Claude Code agent lets you test the parser on real sentences before you write the product code. The same connector works on claude.ai, Claude Desktop and mobile.

For the product itself I’d move to the REST API. The founder platform found that building a list through the MCP connector worked well, and then chose the REST API inside its product. Direct calls used fewer tokens in its chat agent, and they let it control what data its users saw.

If you are building this for your own team: If your reps already work in Claude, the connector may be the whole tool. Our guide to running a B2B prospecting workflow in Claude Code covers that route without any build.

What happens to trust when the first search comes back half empty?

Users decide whether to trust a prospecting tool on its first few searches, so a thin or blank first result has to explain itself.

The AI sales platform we spoke with showed us a search for a known CEO that came back with no title and no company. Its product lead’s concern was simple: nobody wants to spend weeks integrating new data and then find the same gaps. That’s the bar.

A search can fail users in two ways, by returning nobody or by returning rows with blank or out-of-date fields, and each needs its own response from the product.

What the user sees

What your tool should do

Which API piece

A list, and no idea how Claude read the request

Show the filters Claude applied, as chips the user can edit

Your UI, from the plan

Zero people

Re-run with explain turned on, name the filter that removed everyone and say how many people come back without it

remarks on Person Search

A huge or tiny pool

Show the count before pulling rows

total_count, from a 1-result search

A row with a blank field

Show the blank as blank and never fill it with a guess

Response fields as returned

A row that looks out of date

Offer a refresh for that one person

Person Enrich on demand

Show the filters Claude applied: The AI sales platform asked for this. Its goal was to hand users the results and the filters together, so they could fine-tune and see how the AI interpreted the request. Editable filters turn a wrong guess into a one-click fix.

Explain an empty result: When a filters-only search returns zero people, send it again with "explain": true. The response's remarks names the condition that removed every result and how many people match without it. In our test, the "SaaS as an industry" search came back with this, at no credit cost:

{
  "code": "condition_eliminates_all",
  "path": "filters.conditions[3]",
  "message": "experience.employment_details.current.company_industries in ['SaaS'] removes every result (48,457 match without it).",
  "matches_without": 48457,
  "hint": "Resolve the stored value with POST /person/search/autocomplete for experience.employment_details.current.company_industries."
}
{
  "code": "condition_eliminates_all",
  "path": "filters.conditions[3]",
  "message": "experience.employment_details.current.company_industries in ['SaaS'] removes every result (48,457 match without it).",
  "matches_without": 48457,
  "hint": "Resolve the stored value with POST /person/search/autocomplete for experience.employment_details.current.company_industries."
}
{
  "code": "condition_eliminates_all",
  "path": "filters.conditions[3]",
  "message": "experience.employment_details.current.company_industries in ['SaaS'] removes every result (48,457 match without it).",
  "matches_without": 48457,
  "hint": "Resolve the stored value with POST /person/search/autocomplete for experience.employment_details.current.company_industries."
}

Your UI can turn that into: “No one matched ‘SaaS’ as an industry. Remove it to see 48,457 people, or search SaaS as a company category.” The docs say to branch on code and path in your code and treat message as display text that can change.

Show the count first: a 1-result search returns total_count for the full match, and in our test it took a median of 881 ms across 10 runs. Showing "3,593 founders match" before pulling rows lets the user narrow a broad request before it costs anything more.

Never guess a blank: in the company-first run, 5 of 99 founder rows had no person location.None were missing name, title or employer. A blank shown as blank keeps the user’s trust. A guessed value that turns out wrong burns it.

If you are building this for your own team: reps forgive more than paying customers do. They stop using a tool that wastes their morning, and they go back to the old one without telling anyone. The same fixes apply, and you can also sit with them, read their feedback in your own Slack and change the template searches the same week.

What changes when you build it for your own team?

Mostly who pays for credits and where the finished list goes. The parser, the trust fixes and the API calls stay the same.

Area

Built for your customers

Built for your own team

Who types the request

Users of every skill level, often broad

Reps you can train, juniors may prefer fields

What a bad first search costs

A customer who stops trusting the product

A rep who goes back to the old tool

Rate limits

One account limit shared by every customer

Rarely hit by one team

Who pays for credits

You, on every user search

One team budget

Caching

Within each customer's workspace

One cache, checked against your CRM

Raw data shown

Decide what your users see, under your data terms

Internal use

Where the list goes

Your product's own sequencer

Your CRM and sequencer, owned by the rep who pulled it

Signals

A watch per customer's list

One watch on the team's active lists

Speed target

Chat speed, measured at the median and the slow end

Seconds are fine

Build, buy or use Claude with a connector?

Buy when your filters fit a vendor’s and you don’t plan to change data vendor. Apollo's integration lets Claude find people and companies across Apollo's database using natural language, and Salesforce's Prospecting Agent lets you use natural language to define your ideal customer and preview results. For a team whose motion fits either product, buying is the faster route. Explorium publishes a chatbot template that uses Claude to turn a chat request into Explorium API filters, which is a quick start for a team that already works in n8n and uses Explorium's data. If your motion fits one of these, buying is the faster route, and we’d take it.

Use Claude with a connector when the team is small and can live without CRM dedupe and owner assignment. Setup is adding the connector in Claude. The running cost is the data API’s credits.

Build when you need CRM dedupe, owner routing, one shared budget with caps, or filters a vendor’s assistant doesn’t offer.. Count the upkeep as part of the cost, because someone has to maintain the tool schema and rerun the test set every time it changes. That build-or-buy rule is our suggestion, not a law.

If you do roll out your own tool, seed the template searches from the filters your reps already saved in the old tool, so their first search in the new one returns a list they recognize.

What goes wrong when many people search at once?

Speed, shared rate limits and credits per customer are what fail first once real users arrive.

Keep the slow path out of the chat turn

Stream the plan back first, then the count, then the rows, and run enrichment only after the user picks people. These are the times we measured on October 21, 2026, from one laptop, with network time included.

Call

Runs

Median

Slowest

Autocomplete (free)

10

816 ms

844 ms

Count only (1 result)

10

881 ms

929 ms

Company search, 25 rows

10

1,175 ms

1,216 ms

Person search, 25 rows

10

1,973 ms

2,123 ms

Semantic sentence search, 25 rows

6

7.1 s

9.1 s

Person enrich, 10 people

1

1.8 s

n/a

Contact enrich, 10 people, verified business email

1

15.9 s

n/a

The founder platform asked us for search timings at the median and the 90th percentile. Measure them on your own sentences, because the shape of each query changes the time.

Share one rate limit across every customer

Every user search goes through your one API account, so its rate limit is shared by all your customers at once. The documented defaults are 30 requests per minute on person and company search and 15 on person enrich and contact enrich, and the response headers we saw matched them.

Queue requests, read the rate-limit headers, back off with jitter on a 429 as the best-practices guide describes, and ask Crustdata for a higher limit before launch not after.

Cap credits per customer

Read the X-Credits-Used header on every response, store it against the customer who ran the search, and stop or warn when a customer passes their cap.

This one isn’t theoretical. The founder platform’s CEO was direct about who pays when users run wild: “we have to then take the cost.” Cache the people a customer has already paid for within that customer’s workspace, and skip them on the next search with your own exclusion list.

If you are building this for your own team: one team rarely hits the rate limit and has one budget. Our suggestion is to show the estimated cost before a search runs, ask for a confirm above a set number of credits, and set a daily ceiling per rep with an alert at 80% of it. For storing and refreshing the data you pull, our AI SDR data infrastructure guide covers storage in depth.

What does one search cost?

At public list prices, our London example cost 72.67 credits for 10 enriched founders, and the searches alone cost 49.17 credits to return 99 founders and keep 62. Search is billed per result returned and enrichment per person, so most of the cost is in the people you choose to enrich.

Step

What we ran

Credits at list price

Company search

80 results, filtering on category and funding

26.40 (0.03 base + 0.1 category + 0.2 funding, per result)

Person search

99 results, filtering on and returning experience

22.77 (0.03 base + 0.1 filter + 0.1 response, per result)

Keep one per company

62 people, in your code

0

Person enrich

10 people

10.00 (1 per person)

Contact enrich, verified business email

9 of 10 had one

13.50 (1 + 0.5 verified, per person with an email)

Total


72.67

Prices come from Crustdata's pricing page, checked October 21, 2026. Autocomplete is free, a search that returns zero people costs nothing, and a free call to /account/endpoints returns your own account's prices.

Now the number that matters. The people-first version of the London request matched 3,593 founders. Pulling all of them at 0.23 credits a result would cost about 826 credits before you enrich anyone. Asking one question first, or capping results per turn, keeps a broad request from spending that.

And no, building an AI agent isn’t free. Claude bills the parsing call by tokens, and the data API bills per result and per person, as the table above shows.

How do you hand the list to a campaign and keep it up to date?

Enrich only the people the user keeps, then send them to the sequence and watch them for job changes.

On the first part, the founder platform’s CEO said it better than we could: “there’s no point in giving them the data without the enrichment.” A list of names isn’t a finished product. The hand-off belongs inside it.

Enrich only the people the user keeps

Search is cheap per result and enrichment is not, so enrich after the user picks.

In our test, 9 of 10 kept founders had a business email, and all 9 were marked deliverable. Contact enrichment is billed per contact type and is available on enterprise plans. Use the synchronous call for the few people a user is looking at on screen, and the batch call for bulk updates. The AI sales platform's developer planned that same split, with the lowest latency for "the use case where the users want to see the data immediately" and batch for bulk imports.

For your customers: pass the enriched people straight into your product's own sequencer.

If you are building this for your own team: check the CRM and the sequencer before you enrich anyone, so you do not pay for contacts you already have or touch accounts with an open deal.

Step

What to do

Match

Match on a stable key, such as company domain, profile URL or email

Skip

Skip people already in the CRM or enrolled in a sequence

Claim

Hold a short claim window per rep, so two reps cannot pull the same new person on the same day

Write

Upsert instead of creating blindly, with the rep who pulled the list as owner

Conflict

Keep the existing owner and flag the conflict for a manager

The sales team we spoke with, the one planning an internal list tool, treated CRM hand-off as a hard requirement. If the tool couldn’t create leads in the CRM and assign them properly, the search wasn’t useful. We’d build it the same way. For signal-led write-back, where a job change or a funding round creates the record, our guide to building internal sales tools covers the full pipeline.

Watch the people in a campaign

Put the people in an active campaign on a person watch, so a job change reaches your app as a webhook and your handler pauses or rewrites that person's sequence.

The AI sales platform described what happens without it. With monthly updates, every change arrives on the first of the month, and every affected sequence changes on the same day. Its lead’s view was simple: “if somebody changes job, I should stop sending them emails.” They also wanted their prospecting agent to read the signal and decide the next step, which is the right instinct.

watch = requests.post(f"{API}/watch/person", headers=HEADERS, json={
    "entities": {"professional_network_profile_urls": campaign_profile_urls},
    "track": {"field": "experience.employment_details.current", "type": "added"},
    "config": {"trigger": {"type": "interval", "every_hours": 24}},
    "notifications": [{"type": "webhook", "url": "https://your-app.com/webhooks/job-change"}],
}).json()
watch = requests.post(f"{API}/watch/person", headers=HEADERS, json={
    "entities": {"professional_network_profile_urls": campaign_profile_urls},
    "track": {"field": "experience.employment_details.current", "type": "added"},
    "config": {"trigger": {"type": "interval", "every_hours": 24}},
    "notifications": [{"type": "webhook", "url": "https://your-app.com/webhooks/job-change"}],
}).json()
watch = requests.post(f"{API}/watch/person", headers=HEADERS, json={
    "entities": {"professional_network_profile_urls": campaign_profile_urls},
    "track": {"field": "experience.employment_details.current", "type": "added"},
    "config": {"trigger": {"type": "interval", "every_hours": 24}},
    "notifications": [{"type": "webhook", "url": "https://your-app.com/webhooks/job-change"}],
}).json()

The first run is a free baseline, and after that each changed person costs 5 credits at the default 30-day freshness tier and 150 credits at the 1-day tier, which keeps data at most a day old, so pick the tier per campaign. For an agent that writes the follow-up email from the signal, the AI SDR guide covers the outbound side.

How do you test it before anyone relies on it?

Keep a regression set of 30 to 50 real sentences, each with the filters it should produce, and rerun it every time you change the prompt or the tool schema. The founder platform asked us for a set like this because its users’ requests were so broad.

A sentence that silently starts producing a different filter is the bug users notice first.

Track four numbers on every run, with our suggested starting targets in brackets.

  • Empty rate: the share of sentences that return nobody (under 5%).

  • Blank-field rate: the share of rows missing name, title, employer or location (under 10%).

  • Credits per search: the average cost of one sentence before enrichment (set from your own pricing).

  • Speed: the median and slowest time from sentence to first rows (under 3 seconds at the median).

As a reference point, our own run on October 21, 2026 covered one sentence and the variations in the misfires table. One of the ten distinct structured searches came back empty, which was the "SaaS as an industry" case. The blank-field rate was 5 of 99 rows, and person search returned 25 rows in about 2 seconds at the median.

Pilot it on your own team before customers see it. The AI sales platform's own reps use its product, and it planned its pilot on its own workspace, which it called "customer zero" .If you’re building for your own reps, have one of them run the tool next to their usual list building for two weeks and compare the lists.

Where should you start building an AI prospecting tool?

Ship the thin version to one real group of users first, either your own team or one customer, and widen it once the four numbers hold.

The parser will be wrong in ways your test set did not predict, and the trust fixes in this guide are what keep a wrong first search from becoming a lost user.

In the first week, collect your 30 sentences and write the filters each should produce. Next, connect Claude to a data connector and run them, then move the parser into your product with the tool schema above. You can start free with 100 credits at crustdata.com, or book a demo to walk through your query plan.

Frequently asked questions

How do I build my own AI prospecting tool?

Put Claude in front of a people and company data API, so Claude turns the user's sentence into filters through a tool schema you define. Your code checks the values with Autocomplete, runs the searches, shows the results and filters, enriches the people kept and sends them to a campaign.

Can I build an AI agent like this on my own, or create my own AI like ChatGPT?

Yes. You can build the parser and search flow with Claude's tool use and a data API. The work is a tool schema, a query plan and the product around them, with no model to train, and prototyping first in Claude with a data connector makes the early work faster.

How do I use AI for prospecting?

Describe the people you want in a sentence and let Claude turn it into search filters, then check the list before you contact anyone. The parts that make it reliable are showing the filters Claude chose, asking when a request is too broad, and enriching only the people you keep.

Which AI is best for prospecting?

It depends on whether a vendor's filters fit your motion. If they do and you are not changing data vendors, a built-in assistant such as Apollo's Claude integration or Salesforce's Prospecting Agent is the faster pick. If you need your own rules, CRM dedupe or a shared budget, build your own on a data API, as this guide shows.

Is it free to build an AI agent?

No, because Claude charges per use and so does the data API. In our test, searching for 62 founders cost 49.17 credits and enriching 10 of them cost 23.50 more at list prices. Crustdata's free account includes 100 credits, which covers the searches and person enrich in a test like this.

Is it legal to build your own AI prospecting tool?

Building the tool is ordinary software work, and the questions that matter are about the data. Check your data provider's terms for showing data to your own users, and follow the privacy and marketing rules for contacting prospects in each country you sell into. This is not legal advice, so ask your counsel before launch.

Can I send my user's sentence straight to the API?

Crustdata's Person Search accepts a natural-language query (in beta), and it works as a second pass. For the main search, structured filters are faster, can include company facts such as funding stage, and let you show users exactly what was searched.

Should I use MCP or the REST API inside my product?

Use MCP with Claude to prototype and test the parser, then call the REST API from your product. Direct calls use fewer tokens in your own agent and give you control over what data your users see.

What is an AI SDR, and how is it different from this tool?

An AI SDR is software that does a sales development rep's work, from finding prospects to writing and sending outreach. This guide covers the prospecting part, from sentence to list to hand-off. For the outbound agent and its data layer, see our AI SDR guide.

How much does an AI SDR cost?

It depends on the platform and the data behind it. Our AI SDR guide covers the cost of building one on your own data. For the prospecting step alone, the cost table above shows what one search and enrichment cost.

Will SDRs be replaced by AI?

A tool like this takes over list building and lookups, while reps still decide who to contact and what to say. Our AI SDR guide covers where an outbound agent fits next to a human team.

Crustdata is now live in Claude!

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

Sign In