
TLDR: AI SDR research is the account research layer of a sales development workflow, done by an agent on citable public sources. Build it as one structured brief per account from the You.com Research API, gate each brief with code that checks every cited URL against the sources the API returned, refresh cheaply with news search, and keep a person between the brief and any email. This guide gives the schema, the code, the costs, and the failure modes.
Before a first email, a sales development representative (SDR) researches the account: what the company does, whether it fits the profile, what changed lately, and who owns the problem. An AI SDR hands that work to an agent, and the agent is only as good as its research layer, because one wrong detail in a first email reveals the automation at once. This guide builds that layer with the You.com Research API and Web Search API. It is deliberately narrow: it covers research, not sending.
What Should an AI SDR Research Layer Produce?
Four outputs define the job. Company facts: what the company sells, and its stage or size where public pages say so. A fit verdict against your ideal customer profile, with evidence for the fit and evidence against it. Timing signals: dated public events such as funding, launches, hiring, or leadership changes that justify reaching out now. Contact context: who publicly owns the problem, drawn from team pages, talks, and posts. Each output should arrive as a claim attached to a source URL, which is what makes the brief auditable.
Equally important is what the layer should not produce. The Research API reads public web pages and returns cited text or schema-shaped JSON. It is not a contact database, so a verified email address or direct dial belongs to a separate step with a contact-data provider. Our lead enrichment API guide covers that step, and the company data enrichment guide shows how to test providers on your own records. Keep private data, gated directories used against their terms, and anything you could not cite out of the research layer entirely.
| Need | Ask the research layer for | Leave to another step |
|---|---|---|
| Company facts | What the company does, with a source URL | Firmographic fields looked up by identifier |
| Fit | A verdict plus evidence for and against | The final qualification call, which stays with a person |
| Timing | Dated events, each with a source URL | Proof that nothing happened |
| Contact context | Public roles and ownership | Verified email address or phone number |
How Does the Pipeline Fit Together?
Five steps, in order: a queue of target accounts, a cheap signal refresh, one structured brief per account, a code gate on every brief, and human review before anything reaches a CRM or an outbox. The split between search and research is about cost and cadence. As of October 2026, the billing page prices the Web Search API at $5.00 per 1,000 calls, and the Research API at $50 per 1,000 requests at the standard tier. Run the cheap search often and spend a research request only when something changed.
| API step | API and tier | Price per 1,000 requests | Latency |
|---|---|---|---|
| Signal refresh | Web Search | $5.00 | One search round trip |
| Structured brief | Research, standard | $50 | About 10 to 30 seconds |
| Deeper brief | Research, deep | $100 | Under 120 seconds |
The arithmetic favors refreshing by signal. A weekly search over 1,000 accounts costs $5. If 10 percent of them show something new, regenerating those 100 briefs at standard costs another $5, about $10 for the week against $50 to regenerate every brief. Self-serve accounts default to 10 requests per second on both endpoints per the rate limits page, so size your worker pool to keep request starts under that.
How Do You Request a Structured Account Brief?
Ask for a JSON brief instead of prose so every claim travels with a source URL. The module below defines the schema, makes the request, and gates the result. Save it as sdr_brief.py, the name the tests import. Three rules from the structured output guide shaped it. Every property must be required, and a value that may be unknown is declared nullable, so an unknown date stays null instead of invented. The output_schema parameter needs standard effort or higher and returns a 422 with lite. And the API does not add citations to your object: evidence URLs inside your schema are written by the model, so the code checks each one against output.sources.
"""AI SDR account research: one structured brief per account, checked before a rep reads it."""
import http.client
import json
import os
import time
import urllib.error
import urllib.request
RESEARCH_URL = "https://api.you.com/v1/research"
SEARCH_URL = "https://ydc-index.io/v1/search"
RETRY_STATUS = {429, 500, 502, 503, 504}
CLAIM = {
"type": "object",
"properties": {"claim": {"type": "string"}, "source_url": {"type": "string"}},
"required": ["claim", "source_url"],
"additionalProperties": False,
}
SIGNAL = {
"type": "object",
"properties": {
"claim": {"type": "string"},
"date": {"type": ["string", "null"]}, # nullable: unknown stays null, not invented
"source_url": {"type": "string"},
},
"required": ["claim", "date", "source_url"],
"additionalProperties": False,
}
BRIEF_SCHEMA = {
"type": "object",
"properties": {
"what_they_do": CLAIM,
"icp_fit": {"type": "string", "enum": ["strong", "partial", "weak", "unclear"]},
"fit_evidence": {"type": "array", "items": CLAIM},
"disqualifiers": {"type": "array", "items": CLAIM},
"timing_signals": {"type": "array", "items": SIGNAL},
"contact_context": {"type": "array", "items": CLAIM},
},
"required": ["what_they_do", "icp_fit", "fit_evidence", "disqualifiers",
"timing_signals", "contact_context"],
"additionalProperties": False,
}
def post_json(url, body, timeout=180, attempts=4):
"""POST JSON. Retries 429, 5xx, timeouts, and dropped connections; raises anything else."""
headers = {
"Content-Type": "application/json",
"X-API-Key": os.environ["YDC_API_KEY"],
"User-Agent": "sdr-brief/1.0", # Cloudflare answers urllib's default agent with a 403
}
data = json.dumps(body).encode()
for attempt in range(attempts):
retry_after = None
try:
request = urllib.request.Request(url, data=data, headers=headers, method="POST")
with urllib.request.urlopen(request, timeout=timeout) as response:
return json.load(response)
except urllib.error.HTTPError as err:
if err.code not in RETRY_STATUS or attempt == attempts - 1:
raise
retry_after = err.headers.get("Retry-After")
except (OSError, http.client.HTTPException): # timeouts, resets, cut-off bodies
if attempt == attempts - 1:
raise
try:
delay = max(float(retry_after), 0)
except (TypeError, ValueError): # no Retry-After, or an HTTP date
delay = min(2 ** attempt, 60)
time.sleep(delay)
def norm(url):
return url.split("#")[0].rstrip("/")
def research_account(company, domain, icp, post=post_json):
"""One structured brief. output_schema needs standard effort or higher (lite returns 422)."""
question = (
"Research %s (%s) for a sales team. Our ideal customer: %s. "
"Say what the company does, whether it fits, the evidence for and against the fit, "
"dated public events that give a reason to reach out now, "
"and who publicly owns the problem, from team pages, talks, and posts. "
"Cite a page you read for every claim. Return empty lists instead of guessing."
% (company, domain, icp)
)
return post(RESEARCH_URL, {"input": question, "research_effort": "standard",
"output_schema": BRIEF_SCHEMA})
def check_brief(response):
"""Gate a brief. Returns a list of problems; an empty list means ready for human review."""
output = response["output"]
brief = output["content"]
sources = {norm(s["url"]) for s in output.get("sources") or []}
problems = []
claims = [("what_they_do", brief["what_they_do"])]
for key in ("fit_evidence", "disqualifiers", "timing_signals", "contact_context"):
claims += [(key, item) for item in brief[key]]
for key, item in claims:
if norm(item["source_url"]) not in sources:
problems.append("%s cites a page the API did not return: %s" % (key, item["source_url"]))
if not brief["fit_evidence"] and not brief["disqualifiers"]:
problems.append("no evidence for or against fit")
if brief["icp_fit"] == "strong" and not brief["fit_evidence"]:
problems.append("strong fit with no evidence")
return problems
def new_signals(company, seen_urls, post=post_json):
"""Cheap refresh: news from the last week not seen before. Empty is not proof of quiet."""
payload = post(SEARCH_URL, {"query": "%s funding hiring leadership launch" % company,
"count": 10, "freshness": "week"})
news = (payload.get("results") or {}).get("news") or [] # present only with news intent
seen = {norm(u) for u in seen_urls}
return [n for n in news if n.get("url") and norm(n["url"]) not in seen]
Two details in post_json matter in production. It sends its own User-Agent, because as of October 2026 Cloudflare in front of api.you.com answers urllib's default agent with a 403 and error 1010 before the request reaches the API. And it makes up to four attempts, retrying a 429 after the Retry-After delay, which the rate limits page asks clients to honor, and retrying 5xx errors, timeouts, and dropped connections with exponential backoff. Keep that cap low, because a request that timed out on your side may still have run.
The gate does three jobs. It rejects any claim whose URL is not among the pages the API returned, which catches invented citations. It rejects a brief with no evidence either way, since silence is not a fit verdict. And it rejects a strong fit that cites nothing. Passing the gate means the brief is ready for a person, not that it is right: a cited page can exist and still not support the sentence next to it, so reviewers sample claims against their pages. For effort tiers, source control, and background mode, see our Research API guide, and for the SDK path see Research API in Python.
Test the gate offline before it sees a real account. The tests below also check the schema against the main documented rules, which catches a mistake locally instead of as a 422.
import copy
import unittest
import sdr_brief as b
UNSUPPORTED = {
"allOf", "contains", "not", "dependentRequired", "dependentSchemas", "format",
"if", "then", "else", "maxContains", "minContains", "maxItems", "minItems",
"maxLength", "minLength", "maxProperties", "minProperties", "maximum", "minimum",
"multipleOf", "pattern", "patternProperties", "propertyNames",
"unevaluatedItems", "unevaluatedProperties", "uniqueItems",
}
def check_schema(node, depth=1):
"""The main documented output_schema rules, as assertions."""
if depth == 1:
assert node.get("type") == "object" and "anyOf" not in node
assert depth <= 5 and not UNSUPPORTED & set(node) and node.get("type") != "null"
if node.get("type") == "object":
assert node["additionalProperties"] is False
assert set(node["properties"]) == set(node["required"])
for child in node["properties"].values():
check_schema(child, depth + 1)
if node.get("type") == "array":
check_schema(node["items"], depth + 1)
def good_response():
return {"output": {"content_type": "object",
"sources": [{"url": "https://acme.example/about", "title": "About"}],
"content": {
"what_they_do": {"claim": "Acme sells fleet software",
"source_url": "https://acme.example/about/"},
"icp_fit": "partial",
"fit_evidence": [{"claim": "Sells to logistics teams",
"source_url": "https://acme.example/about"}],
"disqualifiers": [],
"timing_signals": [],
"contact_context": []}}, "warnings": []}
class BriefTest(unittest.TestCase):
def test_schema_obeys_documented_rules(self):
check_schema(b.BRIEF_SCHEMA)
def test_clean_brief_passes(self):
self.assertEqual(b.check_brief(good_response()), [])
def test_invented_url_is_flagged(self):
bad = copy.deepcopy(good_response())
bad["output"]["content"]["fit_evidence"][0]["source_url"] = "https://made-up.example/x"
problems = b.check_brief(bad)
self.assertEqual(len(problems), 1)
self.assertIn("made-up.example", problems[0])
def test_strong_fit_needs_evidence(self):
bad = copy.deepcopy(good_response())
bad["output"]["content"].update(icp_fit="strong", fit_evidence=[])
self.assertIn("strong fit with no evidence", b.check_brief(bad))
def test_stored_urls_are_not_new_again(self):
news = [{"url": "https://news.example/acme-raises/"}, {"url": "https://news.example/acme-hires"}]
fake_post = lambda url, body: {"results": {"news": news}}
fresh = b.new_signals("Acme", {"https://news.example/acme-raises/"}, post=fake_post)
self.assertEqual([n["url"] for n in fresh], ["https://news.example/acme-hires"])
if __name__ == "__main__":
unittest.main()
The fixtures are hand-built to match the documented response shape, so these tests check your logic, not the API. Run a dozen real accounts and read every gate failure before a rep sees a brief.
How Do You Keep Briefs Fresh Without Re-Running Research?
Timing signals are the part of a brief that expires. Instead of regenerating every brief on a timer, run the new_signals function weekly. It calls search with freshness set to week and reads results.news, whose items carry a publication timestamp in page_age. News results appear only when the query has news intent, per the live news guide, so an empty list means no news came back, not that nothing happened. Pass the URLs you stored as seen_urls; the function normalizes both sides, so a trailing slash or a fragment does not make an old article look new. Regenerate a brief only for accounts with something new. Set the cadence to match your outreach cadence, because a signal is useful only until the rep acts on it.
What Goes Wrong in AI SDR Research?
Five failure modes show up in this workflow, and each has a detection.
The wrong company. Two companies share a name, and the brief describes the other one. Detection: always pass the account's domain, and require that at least one cited page sits on that domain. The heuristic misfires for companies with thin websites, so route misses to review instead of rejecting them. Our company lookup guide covers entity resolution in depth.
Stale organization facts. The brief names last year's leadership or an old product line, and the first email shows it. Detection: the nullable date field comes back null when the date is not available, so treat an undated signal as unconfirmed, prefer dated sources, and regenerate on new signals instead of leaving a brief from list import untouched.
Confabulated specificity. The agent writes a plausible detail that no source states, such as an invented integration or customer, and it reads smoothly because it was generated. Detection: the URL gate catches invented citations, and a weekly sample of claims checked against their pages catches real citations that do not support the claim. Our LLM citations guide describes that verification pass.
Overconfident fit. A prompt that asks for enthusiasm labels every account a match. Detection: the schema demands a disqualifiers list and offers an unclear label, and you track the share of accounts labeled strong. A share that never moves suggests the prompt is deciding, not the accounts.
Instructions hidden in page text. Pages the research agent reads can contain text aimed at a model, and that text can travel from the brief into a drafted email. OWASP lists prompt injection as LLM01 in its 2025 risks for LLM applications and recommends least privilege and human approval for high-risk actions. Treat brief fields as data and never as instructions, give the drafting step no permission to send, and review every message. Our guide to prompt injection and intent hijacking in AI agents covers the agent side.
When Should a Sales Team Build This?
The answer depends on volume and on how much consistency matters.
| Situation | Start with |
|---|---|
| A few accounts a week | A rep with a search engine; build nothing yet |
| Hundreds of accounts, and briefs must look the same every time | A structured brief per account with the gate |
| You also need verified contact details | The brief plus a contact-data provider |
| Scoring accounts inside Salesforce | The same loop on a weekly schedule, writing the result back to the record |
The last row has a worked example. Our write-up with One on automated spend scoring in Salesforce describes a weekly agent loop that researches unscored or stale accounts with the Research API, maps the output to a tier with a written rationale, and writes the score back to the Salesforce record.
How Do You Evaluate It Before Reps Rely on It?
- Hand-labeled accounts. Have a rep write the fit verdict and two timing signals for 30 accounts they know, then compare each with the brief.
- Unsupported-claim rate. Sample five claims per brief, follow each URL, and count the claims the page does not support. Track it weekly.
- Gate failure rate. Count the briefs that fail the gate. A rise points to prompt or schema drift.
- Fit distribution. Track the share of accounts per fit label, as described above.
- Cost per accepted brief. Divide total spend by the briefs a rep actually used, not by the briefs generated.
The first exercise is small. Pick ten accounts you already know well, run the module, and have the person who knows them mark every claim true, false, or unsupported. The marks tell you whether the layer is ready for real outreach.
Related Guides
Frequently Asked Questions
In this guide it is a pattern rather than one product: an agent prepares account research for a sales rep using a cited research API plus a search API. The research API returns a brief with sources, and the search API supplies cheap, dated news. Verified emails and phone numbers are a separate contact-data step, so an AI SDR research API covers the research half of prospecting.
Ask for structured output where every claim carries a source URL, then check each URL against the sources the API returned and reject any brief that cites a page it did not read. Refuse briefs with no evidence either way. Then sample claims against their pages, because a real page can still fail to support the sentence beside it.
Let it draft, but keep a person between the draft and the send. The research layer in this guide produces cited evidence a rep can check. Outreach is brand voice, and page text that reaches a draft can carry injected instructions, so give the drafting step no send permission and review every message before it leaves.
Match your outreach cadence instead of refreshing once at import. Run a cheap weekly news search with the freshness parameter set to week, compare URLs with what you stored, and regenerate a brief only for accounts with something new. As of October 2026, a standard-effort brief costs about five cents, against half a cent for the search.
LI Test
LI Test
Share Article:
Related resources.

Introducing the You.com Extract API: fetch and parse any URL, with 80% higher accuracy on PDFs
November 17, 2026
Product Updates

How to Use the You.com Research API in Python
November 11, 2026
Blog

How to Use the You.com Web Search API in Rust
November 6, 2026
Blog

How to Use the You.com Contents API in Python
November 4, 2026
Blog

How to Feed Real-Time Data to an LLM with the You.com Web Search API
October 9, 2026
Blog
