You have two pieces of information: a person's name and where they work. You need their professional profile, either to confirm you have the right person, to see their background, or to get something you can actually act on.
This is one of the most common research tasks in B2B and one of the most frustrating, because the obvious approach works for easy cases and fails exactly where it matters. Common names, people who recently moved, companies with several legal entities, and anyone whose display name differs from their legal name all break the straightforward method.
This guide covers every approach, when each one works, and how to do it at volume when checking one person at a time stops being viable.
Why name plus company is harder than it looks
Before the methods, it is worth understanding what makes this ambiguous, because the failure modes drive the technique.
Names are not unique. There are thousands of people sharing any common name. Within a single large company there may be several, which means "name plus employer" is not necessarily a unique key either.
Display names drift from legal names. People go by middle names, shortened forms, anglicized forms, married or maiden names, or a transliteration that one system renders differently from another. The name you were given is frequently not the name on the profile.
Company identity is messy. The employer you were told might be the parent, a subsidiary, an acquired brand, or a regional entity. Someone at a company you know as one name may list a different legal entity entirely.
Your information may be stale. If the name and company came from a list, a CRM export or a conference program, the person may have changed jobs since. Roughly 30% of professionals change roles each year, so a twelve-month-old record has a real chance of pointing at the wrong employer.
Each method below handles these differently, which is the whole reason to know more than one.
Method 1: Search operators
The free approach, and genuinely effective for a small number of people.
Professional profiles are indexed, so a well-constructed search query finds them. The technique is to constrain the search enough that the right person surfaces above the noise.
1"Jane Doe" "Northwind Logistics"
2"Jane Doe" Northwind VP operations
3"Jane Doe" site:example.comRefinements that materially improve the hit rate:
Add the role, not just the company. Names collide; names plus a specific title rarely do.
Try the company's informal name as well as the legal one. People write "Northwind" far more often than "Northwind Logistics Incorporated."
Search the domain, not the company name. If you know they work at a company whose domain is northwind-logistics.com, searching that string sometimes surfaces pages the company name does not.
Use the name in quotes. Without quotes you get results containing either word, which for common names is useless.
When you think you have the right person, confirm with a second fact. Their stated location, their previous employer, their university. One match is a candidate. Two independent matches is an identification.
Where this works: one to twenty people, where the person is reasonably public-facing, and where you have time to read results.
Where it fails: common names, people with no public footprint, anything at volume, and any case where you cannot independently verify the match. It also skews heavily toward senior and technical people, who have more public presence than frontline roles.
Method 2: The company's own site
Underrated and often faster than searching.
Many organizations publish their people. Leadership pages, team pages, author bylines on a blog, conference speaker listings, press releases quoting executives, investor materials, and documentation sites with contributor credits.
This is the most reliable source when it exists, because the company is telling you directly that this person works there in this role. No inference required.
1site:northwind-logistics.com "Jane Doe"
2site:northwind-logistics.com team
3site:northwind-logistics.com leadershipWhere this works: executives, anyone public-facing, technical staff at companies with engineering blogs, and smaller companies that publish their whole team.
Where it fails: most individual contributors at most companies, and anyone at an organization that does not publish staff. Coverage is heavily skewed toward seniority, and the information goes stale without anyone updating it, so a leadership page can be a year out of date with no indication.
Method 3: Work backwards from an email address
If you have, or can construct and verify, the person's work email address, resolving from the address is usually more reliable than searching for the name.
The reason is that an email address is a near-unique identifier. [email protected] points at one mailbox at one organization, which removes the name-collision problem entirely.
1from renidly import Renidly
2
3renidly = Renidly() # reads RENIDLY_API_KEY from the environment
4
5result = renidly.emails.reverse("[email protected]")
6
7if result.found and result.confidence in ("high", "medium"):
8 person = result.person
9 company = result.current_company
10 print(person.full_name, person.title, company.name)If your stack is Node, the same call with camelCase on the response fields:
1import { Renidly } from "renidly";
2
3const renidly = new Renidly();
4
5const result = await renidly.emails.reverse("[email protected]");
6
7if (result.found && ["high", "medium"].includes(result.confidence)) {
8 console.log(result.person.fullName, result.person.title, result.currentCompany.name);
9}Two properties worth knowing. The response grades itself on a four-value confidence scale rather than returning a bare boolean, so you can treat a high match differently from a low one. And person and current_company resolve independently, so a result that identifies the company but not the individual is still a partial answer rather than a failure.
Professional working mailboxes only: public providers, role accounts, disposable addresses and relay services are rejected before any work runs, and that rejection is free. The full model is in reverse email lookup.
The catch: you need the address first. Which is the next method.
Method 4: Name and domain to address, then address to profile
The two-step that solves the general case.
If you have a name and a company but no address, you can resolve the address first and then resolve the profile from it. In practice this is one call, because the finder returns the resolved identity alongside the address.
1found = renidly.emails.find(
2 first_name="Jane",
3 last_name="Doe",
4 domain="northwind-logistics.com", # bare hostname, no scheme, no @
5)
6
7if found.found and found.confidence == "high":
8 verified_address = found.email1const found = await renidly.emails.find({
2 firstName: "Jane",
3 lastName: "Doe",
4 domain: "northwind-logistics.com",
5});The domain parameter is strict: a bare hostname containing a dot. Passing https://northwind-logistics.com or [email protected] returns a validation error naming the field. User-entered company fields are full of full URLs, so normalize before the call rather than handling the error after.
Getting the domain right is the step that decides the outcome. A perfect resolution at the wrong domain is still wrong. Use the domain the company actually operates from, and be careful with subsidiaries, rebrands and acquisitions, because the domain in an old export is frequently not where the person reads mail today.
If you only have a profile link rather than a name, the inverse exists and resolves the current employer for you before searching:
1found = renidly.emails.find_by_url("https://example.com/in/jane-doe")1const found = await renidly.emails.findByUrl("https://example.com/in/jane-doe");You can run either of these on a single person without writing code, using the free email finder, which takes a name and a domain and returns the verified address. The full comparison of methods for the address step is in how to find a work email address.
Method 5: Filtered people search
When the name is common, or when you want to find people at a company matching a description rather than one named individual, searching by criteria beats searching by name.
1page = renidly.data.people.search(
2 organization_slugs="northwind-logistics",
3 title="operations",
4 current_only=True,
5 limit=50,
6)
7
8for person in page:
9 print(person.id, person.full_name, person.title)1const page = await renidly.data.people.search({
2 organization_slugs: "northwind-logistics",
3 title: "operations",
4 current_only: true,
5 limit: 50,
6});Three parameters do the heavy lifting here.
organization_slugs scopes the search to known employers, taking a comma-separated list, which removes the company-ambiguity problem.
current_only=True restricts matching to present roles. Without it, a title search matches anyone who ever held that title, so someone who was in operations in 2016 and is now a CFO comes back in an operations search. This is the single most common cause of confusing results.
title does partial matching with a three-character minimum, which is more useful than exact matching because job titles are not a controlled vocabulary. "VP Operations", "Vice President, Operations" and "Operations VP" are one role and three strings.
For everyone at a company rather than a filtered subset, there is a dedicated path:
1staff = renidly.data.companies.employees(
2 slug="northwind-logistics",
3 current_only=True,
4 title="operations",
5)1const staff = await renidly.data.companies.employees({
2 slug: "northwind-logistics",
3 current_only: true,
4 title: "operations",
5});That endpoint also accepts a sort of newest, oldest or recently_left, and the last one only works with current_only=False since by definition you are asking about people who have gone. The full filter taxonomy is in the people search API guide.
The methods compared
| Method | Handles common names | Scales | Effort | Best for |
|---|---|---|---|---|
| Search operators | Poorly | No | High | A handful of public-facing people |
| Company's own site | Well, when present | No | Low | Executives, smaller companies |
| From an email address | Very well | Yes | Low | When you already hold an address |
| Name + domain resolution | Well | Yes | Low | The general case |
| Filtered people search | Very well | Yes | Low | Common names, or role-based searching |
The practical pattern for most teams: company site or search operators for a small number of important targets where you want to read the context yourself, and resolution for anything beyond that.
Handling the hard cases
Common names
If the name is common, name matching alone will not get you there, and adding more name variants makes it worse rather than better.
Switch from matching the name to filtering the population. Scope to the company, filter by role, and look at the handful of results rather than trying to pick one from a search engine.
1candidates = renidly.data.people.search(
2 organization_slugs="northwind-logistics",
3 title="operations",
4 current_only=True,
5 geo_country_code="US",
6)Then disambiguate with a second attribute you already know: their seniority, their location, their tenure, or their previous employer. One matching attribute is a candidate, two is an identification.
The person has moved
The most common reason a lookup fails when everything about the method is correct.
If your name and company came from a source more than a few months old, assume the company may be wrong. Two options:
Search by name without the company constraint, then read the current employer off the result rather than asserting it going in.
Watch for movement if you are maintaining a list rather than doing one-off research. Rather than re-checking every record, query for movement events and refresh only the records that changed:
1moves = renidly.data.job_changes.search(
2 event_type="joined",
3 organization_ids="org_5ehe8408s7tme",
4 days_ago=90,
5 limit=50,
6)1const moves = await renidly.data.jobChanges.search({
2 event_type: "joined",
3 organization_ids: "org_5ehe8408s7tme",
4 days_ago: 90,
5 limit: 50,
6});Note that this endpoint takes organization IDs (org_…) while people search takes organization slugs. They are not interchangeable, and this catches people out. The full pattern, including the deduplication problem that breaks every first implementation, is in job change signals.
Name variants and non-Latin scripts
Transliteration is not deterministic, so the same name legitimately appears in several spellings across systems and none of them is wrong.
Do not try to generate variants yourself. Filtering by company and role and then matching visually is far more reliable than guessing at spellings, because the population you are matching against is small enough to inspect.
Several legal entities
Large organizations operate under multiple names. If a company search for the name you were given returns nothing, try the parent, the former name before an acquisition, and the regional entity.
Worth deciding explicitly which level of the hierarchy you are modelling before you start, because "the company" has several correct answers depending on whether you care about the legal entity, the operating brand or the commercial account. The reasoning is in the company data API guide.
Doing this at volume
One person at a time is a research task. A thousand people is an engineering task, and the approach changes completely.
Use batch, not a loop
1job = renidly.emails.find_batch([
2 {"first_name": r.first, "last_name": r.last, "domain": r.domain}
3 for r in rows
4])
5
6for row in job.stream():
7 persist(row.matched_input, row)1const job = await renidly.emails.findBatch(
2 rows.map(r => ({ firstName: r.first, lastName: r.last, domain: r.domain }))
3);
4
5for await (const row of job.stream()) {
6 await persist(row.matched_input, row);
7}Up to 1000 items per job, submitted in one request, processed in the background, results keyed back to exactly what you submitted via matched_input. Streaming rather than waiting means a failure partway through does not discard completed work.
This matters more than it sounds. Firing a thousand individual calls generates a thousand requests to be rate limited, has no resumability, and is slower. The full pattern is in batch enrichment at scale.
Normalize your inputs first
Most volume jobs fail on input quality rather than on the API. Before submitting:
Split names properly. A single full_name column needs splitting, and naive splitting on the first space breaks compound surnames and names with particles.
Extract bare hostnames. Company fields contain full URLs, email addresses, and company names rather than domains. Strip to the hostname.
Deduplicate. The same person appearing three times in your list is three billed lookups for one record.
Drop what cannot resolve. Rows with no domain, or a domain with no dot, will fail validation. Filter them out rather than paying for the error.
Budget on submissions, not results
The arithmetic that catches teams out:
1cost = records submitted × rate
2usable records = records submitted × resolution rate
3effective cost = cost ÷ usable recordsLookups that resolve nothing are still billed, because producing a definitive no-match takes the same work as producing a record. At a 60% resolution rate your effective cost per usable record is roughly 1.7 times the headline rate.
Measure your own resolution rate on a 500-record sample before sizing a full run. It is specific to your data: a list of last quarter's inbound behaves nothing like a conference list from 2019.
Every response reports the credits it consumed, so cost per usable record is something you read from a log line rather than reconstruct from an invoice:
1print(found.meta.credit_consumed, found.meta.remaining_balance)Per-route costs are published at a public endpoint needing no key, and current rates are on the pricing page.
Turn on rate limiting before you need it
1from renidly import Renidly, RenidlyConfig
2
3renidly = Renidly(config=RenidlyConfig(
4 auto_rate_limit=True,
5 rate_limit_safety=0.7, # leave headroom for production traffic
6 max_retries=3,
7))rate_limit_safety below 1.0 keeps a bulk job from starving whatever interactive path shares the same key. Running a backfill at 100% of your ceiling alongside a live signup flow is a self-inflicted outage.
Verifying you found the right person
Finding a candidate and confirming it is the right person are different steps, and skipping the second is how wrong data enters a database.
Require two matching attributes. Name plus company is one. Add role, location, tenure or previous employer. One attribute is a candidate; two independent ones is an identification.
Read the confidence grade rather than the boolean. A high confidence resolution can be written straight to a record. A low one belongs in a review queue. Treating every match as equal is how a database becomes something nobody trusts.
Check the employment is current. A resolution can be correct about who someone is and wrong about where they work, if the underlying record has not caught up with a recent move. For anything you are about to act on, confirm the current role.
Store provenance. Record which method found the record, at what confidence, and on what date. When someone later asks why a record says what it says, you want an answer rather than a guess.
What to store once you have it
The decision that determines whether this work survives a year.
Store the opaque identifier, not the name or handle. Every resolved person carries a stable identifier like prsn_06d0d44dogo2m, and every organization carries one like org_5ehe8408s7tme. These never change. Names change, handles change, companies rebrand.
1person = renidly.data.people.retrieve(handle="jane-doe")
2
3if person:
4 store_person_id(record_id, person.id) # persist prsn_…, not the handle1const person = await renidly.data.people.retrieve({ handle: "jane-doe" });
2
3if (person) {
4 await storePersonId(recordId, person.id);
5}The failure mode if you do not is specific and silent. Key your records on a handle, the person edits their profile, your next refresh returns a not-found, and if your code treats not-found as "no data" it writes null over a populated record. Nothing errors. You discover it during an audit.
Worth knowing: a lookup that resolves nothing returns HTTP 200 with a flag in the body rather than a 404, because the request succeeded and the answer is empty. Branch on the response body, never on HTTP status alone. The deeper reasoning on identifiers is in what B2B identity resolution actually is, and the full mechanics of resolution are in the profile lookup API guide.
Refresh by field, not by calendar. Position history is append-only and never changes. Current title and employer die on a job change. Education and certifications are effectively permanent. Refreshing everything on one annual cycle over-refreshes the stable fields and under-refreshes the volatile ones, which is covered in CRM data decay.
Eight mistakes that waste a day
Searching the name without quotes. You get results containing either word. For any common name this is useless.
Trusting the company you were given. If the record is more than a few months old, the employer may be wrong, and every method will faithfully find the wrong person at the wrong place.
Omitting current_only. A title search without it matches anyone who ever held the role. This is the single most common cause of confusing search results.
Passing a URL where a hostname is expected. The domain parameter wants acme.com, not https://acme.com. Normalize before the call.
Accepting a single matching attribute. Name plus company is one attribute. For common names it is not an identification.
Storing the handle as a foreign key. It changes, and when it does your pipeline fails silently rather than loudly.
Looping single calls over a list. Rate-limited, slow, no resumability. Use batch.
Treating a miss as free. It is billed. Budget on submissions, not results, and deduplicate your input first.
Frequently asked questions
How do I find someone's professional profile if I only have their name and company?
Several ways. Search operators with the name in quotes plus the company and role, the company's own team or leadership pages, or a resolution API that takes a name and company domain and returns the matched person. For common names, filtering by company and role beats matching the name.
What if the name is very common?
Stop matching on the name and start filtering the population. Scope to the company, filter by role and location, and disambiguate the handful of results with a second attribute you already know.
How do I know I found the right person?
Require two independent matching attributes, not one. Name plus company is one. Add role, location, tenure or a previous employer.
What if they changed jobs?
Search by name without constraining the company, then read the current employer from the result. If you are maintaining a list rather than doing one-off research, watch for movement events and refresh only the records that changed.
Can I do this for a list of thousands?
Yes, with batch endpoints rather than a loop. Up to 1,000 per job, results keyed back to your inputs. Normalize and deduplicate your input first, because input quality determines the outcome more than anything else.
Do I pay for lookups that find nothing?
Yes, because producing a definitive no-match takes the same work as producing a record. Budget on records submitted rather than records returned.
Is the company website a reliable source?
When it exists it is the most reliable source, because the company is stating the fact directly. But coverage skews heavily toward senior and public-facing roles, and pages go stale without any indication that they have.
What should I store once I find someone?
The opaque stable identifier, not the name or handle. Handles change and anything keyed on them breaks silently.
The one-line version
Name plus company is not a unique key, and treating it as one is why this task fails in exactly the cases that matter. Names collide, display names drift from legal names, company identity is messy, and your source record may be months out of date.
For a handful of important people, search operators and the company's own site are free and give you context you can read yourself. For anything beyond that, resolve rather than search: a name and a company domain in, a graded match out, with the confidence attached so you can treat certainty differently from a guess.
When the name is common, stop matching names and start filtering populations. Scope to the company, filter by role, and disambiguate a short list with a second attribute rather than trying to pick one result from a search engine.
And whatever method found the person, store the opaque identifier rather than the name. That single habit is the difference between a dataset that still works next year and one that quietly fills with nulls.
If you want to try the name-and-domain path on one person before writing any code, the free email finder does it with no signup, and the full set of free tools covers lookup and verification too. For anything programmatic, the Quickstart takes about five minutes, and for volume or a procurement conversation, talk to us directly.


