🔎 LinkedIn Profile Contact Lookup

LinkedIn Contact Lookup — Phone, Email and Profile Data

LinkedIn Contact Lookup takes a specific person — a profile URL, a public-id slug, or a full name — and returns one consolidated row with their best available phone, email, and website, alongside jobTitle, company, seniority, and the resolved profileUrl. It runs a targeted Google search (site:linkedin.com/in/<slug>) through Apify's GOOGLE_SERP proxy and reads only what Google has already indexed in the result snippet — it never logs into LinkedIn or visits a profile page. Sales teams, recruiters, and lead-enrichment pipelines use it to attach a validated phone number or email to a name they already have, without buying a data-broker subscription.

What is LinkedIn Contact Lookup?

LinkedIn Contact Lookup is a targeted, per-person contact-enrichment Actor, not a bulk profile scraper or a keyword-discovery tool. You give it up to as many targets as you list, and for each one it returns exactly one row: the best phone/email/website it could find in a public Google snippet, plus the identity fields (name, headline, job title, company, seniority) parsed from the same result title. No LinkedIn account, cookie, or login is required — the Actor reads Google's public search index, not LinkedIn itself.

• Three ways to identify a target: a full LinkedIn profile URL, a bare public-id/vanity slug, or a person's full name — the Actor auto-detects which one you supplied.
• Name disambiguation: an optional company value is appended to name-mode searches so "John Smith" at a specific employer doesn't return the wrong John Smith.
• Validated phone extraction: every phone-like digit run in the snippet is passed through the phonenumbers library before it's accepted — connection counts, follower counts, and years are rejected, not just filtered by regex.
• Country-aware number resolution: the country input supplies the dial code used to interpret national-format numbers (07911… → +447911…); numbers already written in international format are kept as-is.
• Depth control per target: maxPagesPerTarget sets how many Google result pages (10 results each) are read before the Actor consolidates the best contact and moves to the next target.
• Standard Apify dataset output: results land in the run's default dataset, exportable as JSON, CSV, Excel, XML, HTML, or RSS like any Apify Actor's dataset — no proprietary export step to configure.

What data can I extract with LinkedIn Contact Lookup?

Every run pushes exactly the 24 fields below — the same set the default dataset view displays, just reordered for the table. Nothing is written that isn't also visible in the view; there are no hidden extra columns.

Field	Example Value	Use Case
target	"jordan-blake-mktg"	The raw input value you supplied, for joining results back to your source list
inputMode	"slug"	Which of the three modes (url / slug / name) the target was classified as
found	true	Whether a matching LinkedIn result was indexed by Google at all
name	"Jordan Blake"	Parsed from the LinkedIn result title
headline	"VP Marketing - Acme Growth Co"	Parsed headline text from the title
jobTitle	"VP Marketing"	Parsed current title
company	"Acme Growth Co"	Parsed current employer
seniority	"VP"	Rule-based label derived from job title/headline text
publicId	"jordan-blake-mktg"	Resolved LinkedIn public-id / vanity slug
profileUrl	"https://www.linkedin.com/in/jordan-blake-mktg"	Canonical https://www.linkedin.com/in/<slug> URL
phone	"+14155550142"	Best phone number, validated and formatted E.164, or null
phoneCountry	"United States"	Country name derived from the phone number's own prefix
phoneCountryCode	"US"	ISO-3166 alpha-2 derived from the phone number's own prefix
email	"jordan.blake@acmegrowth.io"	Best email address found in the snippet, or null
emailDomain	"acmegrowth.io"	Domain portion of email, or null
website	"https://acmegrowth.io"	Best non-LinkedIn website found in the snippet, or null
platform	"Linkedin.com"	The searched site, derived from the platform input
country	"United States"	The country you selected in the input (used for search localisation)
dialCode	"+1"	The dial code tied to the country you selected
sourceUrl	"https://www.linkedin.com/in/jordan-blake-mktg"	The URL of the Google result the row was built from
snippet	"Jordan Blake - VP Marketing - Acme Growth Co | LinkedIn. Reach me at jordan.blake@acmegrowth.io..."	The flattened snippet text the contact was extracted from
query	"site:linkedin.com/in/jordan-blake-mktg"	The exact Google query that produced the match
scrapedAt	"2026-07-26T09:14:02Z"	ISO-8601 UTC timestamp of the run
error	null	null on a full match, otherwise a note explaining what's missing

Contact and identity signals

phone, email, and website are the decision-driving fields — they're what most integrations pull straight into a CRM or outreach tool. Each is the first real value found across all Google results for a target, preferring the result whose slug matches the resolved profile when one is known. name, headline, jobTitle, and company come from parsing the LinkedIn result's page title (a "Name - Title - Company | LinkedIn" pattern); seniority is then derived from that same text against a fixed ruleset (C-Level, VP, Director, Manager, Senior, Entry) rather than an official LinkedIn field. None of these are guaranteed present — a row can have found: true with every contact field null if Google indexed the profile but no contact string.

Targeting and provenance fields

inputMode, publicId, and profileUrl tell you exactly how the target was resolved and let you re-run a lookup precisely. country and dialCode record which localisation you selected, separately from phoneCountry/phoneCountryCode, which describe the number that was actually found — the two can legitimately differ (you search from the UK, but the indexed number is a US line). sourceUrl, snippet, and query are the audit trail: the exact result and search string a claim came from, so a human can verify it before it's used for outreach. scrapedAt timestamps the observation, and error is the one field to check first when phone/email/website are all null — it distinguishes "no LinkedIn result at all" from "profile resolved, contact just wasn't indexed."

Why not build this yourself?

There's no official LinkedIn API a third-party developer can call for arbitrary contact lookup — LinkedIn's public developer surface (Sign In with LinkedIn, the Marketing Developer Platform) requires partner approval and does not expose a people-search or contact endpoint. Building an equivalent yourself means scraping Google's SERP directly, and that turns out to be harder than it looks.

Google returns a JS-gated shell instead of results to requests it doesn't trust, and the Actor's own block-detection logic checks both HTTP status and body text for phrases like "our systems have detected unusual traffic" before deciding a page is usable — a naive scraper that only checks the status code will silently collect empty pages. Getting past that reliably requires routing through a residential-grade SERP proxy pool; the Actor forces Apify's GOOGLE_SERP proxy group specifically, because the code comments note that the general RESIDENTIAL group serves the JS-gated shell with no results, not a real Google page. Even through that proxy, requests retry up to 3 times with randomized 1–6 second jitter between attempts to avoid tripping rate limits.

Then there's the extraction itself: a phone-like digit run in a snippet is just as likely to be "500+ connections," a follower count, or a birth year as a real number. This Actor pipes every candidate through the phonenumbers library's is_valid_number check before accepting it — building and tuning that false-positive filter, plus the title-parsing and seniority-classification rules on top, is most of the actual engineering effort in a project like this.

Build it yourself if you need custom parsing logic beyond phone/email/website, or want to self-host the proxy relationship. Use this Actor if you want a working, retry-and-block-aware pipeline today without maintaining SERP-parsing code against a page layout that changes without notice.

How to use data extracted from LinkedIn?

Sales and business development

A rep exports a prospect list of LinkedIn URLs or names + companies from a CRM, feeds it into targets (with company set for name-mode entries), and gets back phone, email, jobTitle, and seniority for each. Rows where error is null and phone or email is populated go straight into an outreach sequence; rows with a non-null error get flagged for manual LinkedIn lookup instead of silently dropped.

Recruiting and staffing agencies

A recruiter working a shortlist of candidate profile URLs runs them through in one batch and gets back email/phone alongside jobTitle and company, so outreach doesn't depend on LinkedIn InMail credits. Because snippet and sourceUrl are returned with every row, a recruiter can verify a contact detail against its original public source before adding it to an ATS record.

Market research and intelligence

Feeding in every named decision-maker at a target account list and reading back seniority and jobTitle produces a quick map of who holds C-Level, VP, or Director titles at each company — useful for account-based marketing planning or org-chart reconstruction from public signals, without needing Sales Navigator seats for every researcher.

AI agents and automated pipelines

Because the Actor is a standard Apify Actor, an agent framework can call it through the Apify API, pass a list of names or URLs pulled from a form submission or CRM webhook, and parse the returned phone/email/company fields directly into a downstream enrichment or lead-scoring step — no scraping code to maintain inside the agent itself.

🔼 Input sample

targets and country are the only required fields. country defaults to "United Kingdom (+44)" if you don't override it, so it's easy to forget to set it for a US or other-region target list — do this deliberately, since it drives both the Google search region and how national-format phone numbers get interpreted.

Parameter	Required	Type	Description	Example Value
targets	Yes	array of strings	One entry per person: a LinkedIn profile URL, a public-id/vanity slug, or a full name.	["https://www.linkedin.com/in/williamhgates", "satyanadella"]
country	Yes	string (enum, 194 values)	Localises the Google search region and interprets national-format phone numbers. Defaults to "United Kingdom (+44)".	"United States (+1)"
company	No	string	Optional company name appended to name-mode lookups to disambiguate common names. Ignored for URL/slug targets.	"Microsoft"
platform	No	string (enum)	Site to search. Currently locked to a single value: "Linkedin".	"Linkedin"
maxPagesPerTarget	No	integer (min 1, max 10, default 2)	Google result pages (10 results each) read per target before consolidating the best contact.	2
proxyConfiguration	No	object	Proxy toggle. The Actor always forces the GOOGLE_SERP proxy group for Google requests regardless of any group chosen here — this field only controls whether a proxy is used at all.	{"useApifyProxy": true}

{
  "targets": [
    "https://www.linkedin.com/in/williamhgates",
    "satyanadella",
    "Melinda French Gates"
  ],
  "company": "",
  "platform": "Linkedin",
  "country": "United States (+1)",
  "maxPagesPerTarget": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Common pitfall: the platform field looks like it accepts a site choice, but its enum currently holds exactly one option — "Linkedin" — so it has no practical effect today. The field that actually changes behaviour per run is country: getting it wrong doesn't break the search, but it can turn a valid national-format phone number into a rejected candidate, because normalize_phone uses the selected country's dial code to expand numbers that don't start with + or 00.

🔽 Output sample

Results are typed, consistently-keyed JSON — every row carries the same 24 keys whether or not a contact was found, with unmatched fields returned as null rather than omitted. Export from the Apify Console or API as JSON, CSV, Excel, XML, HTML, or RSS.

{
  "target": "jordan-blake-mktg",
  "inputMode": "slug",
  "found": true,
  "name": "Jordan Blake",
  "headline": "VP Marketing - Acme Growth Co",
  "jobTitle": "VP Marketing",
  "company": "Acme Growth Co",
  "seniority": "VP",
  "publicId": "jordan-blake-mktg",
  "profileUrl": "https://www.linkedin.com/in/jordan-blake-mktg",
  "phone": "+14155550142",
  "phoneCountry": "United States",
  "phoneCountryCode": "US",
  "email": "jordan.blake@acmegrowth.io",
  "emailDomain": "acmegrowth.io",
  "website": "https://acmegrowth.io",
  "platform": "Linkedin.com",
  "country": "United States",
  "dialCode": "+1",
  "sourceUrl": "https://www.linkedin.com/in/jordan-blake-mktg",
  "snippet": "Jordan Blake - VP Marketing - Acme Growth Co | LinkedIn. Reach me at jordan.blake@acmegrowth.io or +1 415-555-0142...",
  "query": "site:linkedin.com/in/jordan-blake-mktg",
  "scrapedAt": "2026-07-26T09:14:02Z",
  "error": null
}

When no LinkedIn result is indexed for a target at all, found is false, every identity and contact field is null, and error reads "No matching LinkedIn result was indexed by Google for this target.". When a profile is resolved but the snippet carried no phone, email, or website, found is true, identity fields are populated, contact fields stay null, and error reads "Profile resolved, but no phone/email/website was present in Google's indexed snippet.".

How do you target specific profiles precisely?

Precision here comes from picking the right input mode per target, not from a filter panel. A profile URL or bare slug builds the tightest possible query — site:linkedin.com/in/<slug> — restricting Google to that exact profile path, with a name-based fallback query only used if the exact-path query returns nothing. A name alone is the loosest input and the one most likely to collide with someone else sharing that name; adding company narrows the query to site:linkedin.com "<name>" "<company>", tried before the bare-name query.

maxPagesPerTarget is the volume control: each unit is one more page of 10 Google results read before the Actor gives up and consolidates whatever it found. The default of 2 (20 results) is enough for most single-person lookups; raising it toward the maximum of 10 widens the net for a common name at the cost of more requests per target, since the Actor stops at the first query that returns any match rather than always running every page.

{ "targets": ["https://www.linkedin.com/in/satyanadella"], "country": "United States (+1)" }

Most precise — an exact profile URL, no name-collision risk.

{ "targets": ["Jordan Blake"], "company": "Acme Growth Co", "country": "United States (+1)" }

Common name — company disambiguates which "Jordan Blake" you mean.

{ "targets": ["Jordan Blake"], "maxPagesPerTarget": 6, "country": "United States (+1)" }

No company known — widen the search instead, at the cost of more requests.

▶️ Want to try other LinkedIn scrapers?

SimpleAPI doesn't currently publish another LinkedIn-specific Actor alongside this one. If you're building out a broader contact-enrichment or social-lookup pipeline, these SimpleAPI Actors cover comparable ground on other platforms:

Scraper Name	What it extracts
Instagram Profile Contact Enricher	Direct-list Instagram contact enrichment — paste profiles you already have, get authoritative contacts back
Instagram Followers Scraper	Genuine followers of a public Instagram profile, with optional per-follower bio/contact enrichment
Facebook Photos Scraper	Public Facebook profile & page photos with real dimensions, captions, and engagement counts
Facebook Groups Search Scraper Plus	Discovers Facebook groups by keyword or URL, with member counts and derived analytics
Facebook Group Posts Scraper Pro	Posts from public Facebook groups, with reactions, comments, hashtags, and mentions

How to extract LinkedIn contact data programmatically

The Actor runs like any Apify Actor: start a run with an input payload, poll for completion, then read the default dataset. No LinkedIn credentials are involved anywhere in the call — only your Apify API token.

Python example

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "targets": ["https://www.linkedin.com/in/satyanadella", "Jordan Blake"],
    "company": "Acme Growth Co",
    "country": "United States (+1)",
    "maxPagesPerTarget": 2,
}

run = client.actor("linkedin-profile-contact-lookup").call(run_input=run_input)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("phone") or row.get("email"):
        print(row["name"], row.get("phone"), row.get("email"))

Export to spreadsheets or CRM

Every run's dataset can be downloaded directly as CSV or Excel from the Apify Console, or fetched via the API in the same format. Map name to a "Contact Name" column, phone and email to their respective outreach fields, and company/jobTitle to your CRM's account and title fields — the JSON keys line up one-to-one with typical CRM import templates, so no renaming is usually needed beyond the column headers themselves.

Is it legal to scrape LinkedIn?

Scraping publicly indexed information is generally permitted, but the records this Actor surfaces — names, phone numbers, and email addresses tied to identifiable people — are personal data, so GDPR (if you or the data subject are in the EU/UK) and CCPA (for California residents) govern how you store, use, and retain it. Google only surfaces what it has already indexed from a public page, and this Actor reads that indexed snippet rather than a private or logged-in view of LinkedIn. You are responsible for having a lawful basis before using the output for outreach, and for honoring deletion and opt-out requests once contacts are stored. LinkedIn's own User Agreement restricts automated data collection from its platform directly; this Actor's design — querying Google rather than LinkedIn — does not remove that obligation to use the resulting data responsibly. Consult legal counsel for commercial applications involving bulk storage of personal data.

❓ FAQ

What if a LinkedIn profile has been deleted, renamed, or made private since Google indexed it?

The row still reflects whatever Google had indexed in its snippet at the time of the search — the Actor never re-visits LinkedIn to confirm the page still exists in that state. Use sourceUrl and scrapedAt to check how current a result might be, and treat a returned contact as an indexed snapshot rather than a live read of the profile.

Can I get job title and company along with the contact details?

Yes. jobTitle, company, headline, and a rule-based seniority label are parsed from the same LinkedIn result title used to resolve the profile — no separate lookup or extra charge is needed to get them alongside phone/email/website.

How accurate is the phone and email data?

The Actor returns exactly what Google's public snippet contains at request time; it doesn't verify that a number is still in service or an inbox still active. Phone numbers are validated for correct format with the phonenumbers library before being returned, which rules out false positives like connection counts, but format-valid isn't the same as currently reachable — run a standard email/phone verification step before using results for outbound outreach at scale.

How many targets can I process per run?

The targets array has no documented maximum length in the input schema — you can list as many as you need. In practice, run time scales linearly with target count, since targets are processed one at a time rather than concurrently, each involving up to maxPagesPerTarget sequential Google requests plus retry delays.

How do I avoid matching the wrong person with a common name?

Set the company field whenever you're searching by name rather than URL or slug — it's appended directly into the Google query (site:linkedin.com "<name>" "<company>") and tried before the bare-name fallback, which is the single biggest lever against a name collision.

Does LinkedIn Contact Lookup work with Claude, ChatGPT, and AI agent frameworks?

There's no dedicated MCP server for this Actor. It's callable as a standard Apify Actor run through the Apify API or apify-client SDK, which any agent framework capable of making an HTTP call or using a Python/JS SDK can invoke directly.

How does this compare to other LinkedIn contact scrapers?

As observed on the Apify Store on 2026-07-26, agentx/linkedin-profile-lookup accepts a single profile URL per run and explicitly states no output field represents an email or phone number — it returns headline, experience, and activity data instead, not contact details. freecamp008/linkedin-b2b-lead-profile-scraper accepts bulk profile URLs and claims verified emails with a deliverability score, but its documented output has no phone-validation step comparable to this Actor's phonenumbers-backed E.164 normalization. anshumanatrey/linkedin-harvester works in the opposite direction — email in, LinkedIn URL out — rather than resolving phone/email from a name or profile.

Can I use this without a LinkedIn account or API key?

Yes. The Actor never logs into LinkedIn and doesn't accept LinkedIn credentials at all — you only need an Apify account and API token to run it, since all requests go to Google's public search, not to LinkedIn directly.

What happens if I disable the proxy toggle?

Requests are sent without a proxy, and Google is likely to block them — the Actor logs a warning to that effect at the start of the run. proxyConfiguration.useApifyProxy is on by default for this reason, and the underlying proxy group used when it's on (GOOGLE_SERP) isn't configurable through this field.

Conclusion

LinkedIn Contact Lookup turns a name, slug, or profile URL into a validated phone number, email, and website where one is publicly indexed — one row per target, with the identity fields and audit trail (sourceUrl, snippet, query) needed to verify the match before you act on it. It's built for targeted, per-person enrichment rather than bulk profile harvesting: sales teams, recruiters, and researchers who already know who they're looking for use it to fill in the contact details a CRM record is missing. Start a run from the Apify Console with a short targets list to see the output shape, then scale up through the API once the match quality looks right for your list.