You can add prospect lookup as a Claude tool call by integrating a prospect enrichment API that returns company and contact intelligence as structured JSON. CallPrep's API lets you do this in about 5 minutes with native Claude tool support, replacing what used to take an hour to wire up through third-party automation templates.
If you're building a sales AI agent, CRM workflow, or internal tool that needs to pull prospect context on demand, connecting prospect lookup as a Claude tool call solves a real problem: your AI can now ask for company intel, decision-maker data, and talking points without leaving the conversation thread.
The old way of enriching prospects in AI workflows felt fragile. You'd build an n8n flow, chain API calls across 3 or 4 data providers, parse the responses, and hope the JSON schema stayed stable. Every change to the flow meant revisiting templates and testing again.
Claude tool calls flip this on its head. Your AI agent has a function signature. The function knows exactly what data it needs. It calls the function when it needs prospect data. It gets back structured JSON. No hidden workflows. No brittle templates. The logic is inside your agent code where you can see it.
The other win is latency. When prospect lookup is a tool call, the AI doesn't wait for a background job to finish. It calls the function, gets back company overview and decision-maker names in under 2 seconds, and immediately weaves that context into the conversation.
I built this feature after watching a customer spend 45 minutes setting up prospect enrichment in their sales AI. They wanted their Claude agent to pull live company intel before composing outreach emails. By the time they got it working, they'd lost half a sprint. With native tool support, that same integration takes 25 minutes including testing.
Claude tool calls work by defining a function schema and letting the AI decide when to invoke it. Here's the shape of a prospect lookup tool call.
First, you define the tool in your Claude API call. The tool needs a name, description, and input schema that tells Claude what parameters to pass.
const tools = [
{
name: "lookup_prospect",
description: "Retrieve company overview, key decision-makers, and talking points for a prospect",
input_schema: {
type: "object",
properties: {
email: {
type: "string",
description: "Prospect email address (required)"
},
company_name: {
type: "string",
description: "Company name (optional, helps with disambiguation)"
}
},
required: ["email"]
}
}
];
Second, you pass this tool schema to the Claude API when you create a message. Claude reads the schema and learns that it can call this function when it needs prospect data.
Third, you implement the actual function that handles the tool call. When Claude invokes the tool, it sends the email address you provide. Your function calls the prospect enrichment API, gets back JSON with company intel and decision-maker names, and returns that JSON to Claude.
Fourth, Claude receives the response and incorporates it into the conversation context. On the next message, the AI has access to that prospect data and can reference it when composing outreach, identifying next steps, or flagging risks.
CallPrep's API is built specifically for this pattern. You send a prospect email. You get back company overview, employee count, industry, location and a list of decision-makers with their titles and LinkedIn URLs.
Here's a working example using the CallPrep API as a Claude tool.
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const tools = [
{
name: "lookup_prospect",
description: "Retrieve company overview, decision-makers and talking points for a prospect",
input_schema: {
type: "object",
properties: {
email: {
type: "string",
description: "Prospect email address"
}
},
required: ["email"]
}
}
];
async function lookupProspect(email) {
const response = await fetch("https://api.callprep.app/v1/enrich", {
method: "POST",
headers: {
"Content-Type": "application/json",
"Authorization": `Bearer ${process.env.CALLPREP_API_KEY}`
},
body: JSON.stringify({ email })
});
if (!response.ok) {
throw new Error(`API error: ${response.statusText}`);
}
return await response.json();
}
async function runAgent(userMessage) {
const messages = [
{
role: "user",
content: userMessage
}
];
let response = await client.messages.create({
model: "claude-3-5-sonnet-20241022",
max_tokens: 1024,
tools: tools,
messages: messages
});
while (response.stop_reason === "tool_use") {
const toolUse = response.content.find(block => block.type === "tool_use");
if (toolUse.name === "lookup_prospect") {
const prospectData = await lookupProspect(toolUse.input.email);
messages.push({
role: "assistant",
content: response.content
});
messages.push({
role: "user",
content: [
{
type: "tool_result",
tool_use_id: toolUse.id,
content: JSON.stringify(prospectData)
}
]
});
response = await client.messages.create({
model: "claude-3-5-sonnet-20241022",
max_tokens: 1024,
tools: tools,
messages: messages
});
}
}
const finalResponse = response.content.find(block => block.type === "text");
return finalResponse.text;
}
// Example usage
runAgent("Help me draft an outreach email to sarah@acme.com").then(console.log);
When you run this code, Claude will see the lookup_prospect tool in its context. When you ask it to draft an outreach email to a prospect, Claude will automatically invoke the tool, CallPrep's API will return company intel and decision-maker data, and Claude will use that context to write a more targeted email with specific company details and names.
The response from CallPrep includes company overview, employee count, funding stage if available, decision-makers with titles and LinkedIn profiles, and suggested talking points based on company positioning and recent news.
Prospect lookup as a tool call works best in 4 specific workflows.
Sales AI agents that compose outreach. Your agent reads a CSV of prospects. For each prospect, it calls lookup_prospect. It gets back company intel and decision-maker names. It drafts a personalized email that references the company's funding round or recent hiring in engineering. The email is 10x more targeted than a template.
CRM workflows that enrich contacts on ingest. When a new lead lands in HubSpot via a form or API, you trigger a Claude agent to look up the prospect and auto-populate company fields, decision-maker lists, and custom properties. No manual data entry. No half-blank contact records.
Internal tools that surface prospect context during calls. If you're building a Slack bot or internal dashboard for your sales team, you can wire prospect lookup as a tool call behind the scenes. When a rep asks "Who's the VP Eng at Acme?", the bot invokes the tool and returns the name and LinkedIn URL in seconds.
Multi-turn research conversations. Your Claude agent can call lookup_prospect multiple times in a single conversation. First it looks up the prospect company. Then it looks up a decision-maker. Then it surfaces competitive intel. Each tool call adds more context to the conversation without requiring you to pre-fetch all the data upfront.
I've watched developers make 3 mistakes when wiring prospect lookup tool calls.
Mistake 1: Not handling API errors gracefully. When the prospect API doesn't find a match, it returns a 404 or a partial response. If your code doesn't check for this, Claude receives bad JSON and the agent gets confused. Always validate the response before passing it to Claude. If the lookup fails, return an explicit error message like "Prospect not found in our database" so Claude knows to ask the user for more information.
Mistake 2: Over-fetching data and hitting rate limits. If you're looking up 100 prospects in a loop, you'll hit the API rate limit. Build in exponential backoff. Add a delay between calls. If you're processing a batch, consider pre-fetching the data outside the Claude conversation and passing it as context instead of using tool calls inside the loop.
Mistake 3: Ignoring the token cost of large JSON responses. CallPrep's API returns rich data. If you include the full decision-maker list and all talking points in every tool response, you'll burn through tokens fast. Be selective. Return only the fields you actually need. If your agent needs company overview and 2 decision-makers, ask the API for just those fields instead of the entire response.
You need 4 things to ship prospect lookup as a Claude tool call today.
First, get a CallPrep API key. Go to callprep.app/api, sign up, grab your free API key. No credit card. You get 100 free lookups per month on the free tier.
Second, install the Anthropic SDK for your language. For Node.js, run npm install @anthropic-ai/sdk. For Python, run pip install anthropic.
Third, copy the tool definition and the lookupProspect function from the example above. Swap in your API key and your API endpoint.
Fourth, test with a real prospect email. Run the agent code. Watch Claude invoke the tool. Verify the prospect data comes back and the agent uses it in its response.
That's genuinely it. 5 minutes. Then you can start building agent workflows that actually understand who they're talking to.
Want to skip the integration work and let someone else handle it? CallPrep's free API tier includes everything you need to get started. Set your API key and you're calling the enrichment endpoint in minutes. Check out callprep.app/api for docs and a live playground where you can test prospect lookups before writing any code.
The shift to AI agents in sales is real. Teams are building Claude agents to qualify leads, draft outreach, manage follow-ups and analyze call transcripts.
But an AI agent without prospect context is just a template writer. It doesn't know who it's talking to. It doesn't have company intel. It can't reference recent funding rounds or hiring announcements. The email it writes sounds generic.
Prospect lookup as a tool call bridges that gap. Your agent becomes context-aware. It pulls live company data on demand. It weaves that context into every conversation. The outputs go from generic to personalized in a single function call.
If you're building sales AI, this is table stakes now. The teams shipping enrichment-aware agents are the ones closing more deals because their outreach and positioning actually reflect what they know about their buyers.
If you're building a Claude-based sales tool and want to add prospect enrichment, start here. Get the free API key. Test a lookup. Wire it as a tool call. Ship it. Most teams finish the integration in under an hour.
If you're a sales rep or manager looking for an easier way to prep calls with AI, check out the free sales intelligence tools guide and learn how to layer prospect research into your pre-call routine. Also read equipping your AI sales agent with prospect lookup capabilities to understand how your tech stack can support richer prospect context.
Can I use prospect lookup tool calls with other AI models?
Yes. Tool calls work with GPT-4, Gemini, and Bedrock Claude. The tool definition schema is nearly identical across all models. CallPrep's API is model-agnostic. You can swap Claude for GPT-4 and the integration stays the same.
How much does the CallPrep API cost?
Free tier gives you 100 lookups per month with no credit card. Paid plans start at $49 per month for 5000 lookups. Most small teams stay on free. Most agencies and large sales orgs move to paid after 2 weeks.
What if the prospect isn't in your database?
CallPrep returns a "not found" response. Your code should catch this and tell Claude the lookup failed. Claude will then ask the user for more information or suggest alternative data sources.
Can I cache prospect data across multiple Claude conversations?
Yes. You can fetch prospect data once, cache it in your database or in-memory, and pass it as context in subsequent conversations. This saves API calls and tokens. For real-time workflows, just call the tool each time.
How do I handle multi-email prospects or companies with multiple domains?
Pass the primary prospect email to lookup_prospect. If that fails, try the company domain. CallPrep's API returns all associated contacts and their titles, so you get the full company picture from a single lookup.
AI Call Prep sends you a full prospect briefing before every call. Automatically.
Add to Chrome - Free