# LinkedIn Profile Finder by Name & Company — $3.20/1k (`sputnikapi/name-to-profile`) Actor

Find a person’s LinkedIn profile from their full name — anchored to a company site domain for precision, or from the bare name when it is unique. Ambiguous names come back as a free row with the namesake count instead of a wrong guess. $3.20 per 1,000 resolved, 20% under the shelf. Misses are free.

- **URL**: https://apify.com/sputnikapi/name-to-profile.md
- **Developed by:** [Sputnik API](https://apify.com/sputnikapi) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.20 / 1,000 name resolved (summary)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Profile Finder by Name & Company

> **$3.20 per 1,000 resolved names, $8 with the full 164-field document — and
> a namesake is a free row, never a wrong guess.** The shelf's by-name Actor
> charges a page fee *plus* a per-profile fee, so one resolved name costs
> about $6 per 1,000 before you see whether it is even the right person.

Resolve full names to LinkedIn profiles — honestly. A name alone is not
an identity: this actor never guesses between namesakes.

Two modes, picked automatically:

1. **With a company domain** (`companyDomain`): each name is anchored to one
   employer, which makes even common names resolvable. "Satya Nadella" +
   `microsoft.com` finds exactly the person you meant.
2. **Bare names**: a name resolves only when **exactly one profile** in the
   database carries it. Namesakes come back as a free `ambiguous` row that
   tells you *how many* people share the name (`_nameMatchCount`) — so you
   know to add a company domain and retry.

This is a **database lookup, not a live scrape**, over one billion
professional profiles, with a freshness stamp on every row.

### Input

```json
{
  "names": ["Satya Nadella", "Jane Doe"],
  "companyDomain": "microsoft.com",
  "fullOutput": false
}
```

### What you get — 60+ fields per resolved name, 164 with `fullOutput`

| Group | Summary card (default, $0.0032/resolved) | Full document (`fullOutput: true`, $0.008/resolved) |
|---|---|---|
| Identity | full name, first/last, headline, photo, profile slug | same + background image |
| Current role | job title, employer name + slug (flat columns), position dates, industry | + role descriptions, employment type, job function |
| Career history | current positions | **every past position** with dates and descriptions |
| Education & certifications | schools, degrees, fields of study, dates; cert names, authorities | + descriptions, grades, license numbers |
| Skills, languages, bio | full skills list, languages, "about" text | same |
| Location & seniority | city/state/country, experience years, tenure, decision-maker flag | same |
| Salary estimate | inferred min–max | same |
| Social links | professional profile URL, GitHub, Twitter/X, Facebook, website | same |
| Contacts | — | **email addresses and phone numbers when on record** |
| Deep sections | — | publications, patents, awards, projects, articles, related profiles |
| Honesty meta | `_status`, `_freshness`, `updatedAt`; `_nameMatchCount` in bare-name mode | same + per-section coverage map |

### Output

One row per name, `_status` explaining each (`found` / `ambiguous` /
`not_found` / `invalid`). Resolved rows carry the profile card,
`_freshness`, `_fullData` — a link to the complete document via the direct
API — and flat `companyName` / `companySlug` columns when a current
position is on record. In bare-name mode resolved rows also carry
`_nameMatchCount`, and free `ambiguous` rows carry it too — the honest
namesake count. A real resolved row:

```json
{
  "_status": "found",
  "_input": { "name": "Satya Nadella", "domain": "microsoft.com" },
  "_freshness": "fresh_90d",
  "companyName": "Microsoft",
  "companySlug": "microsoft",
  "_view": "lite-v3",
  "fullName": "Satya Nadella",
  "headline": "Chairman and CEO at Microsoft",
  "jobTitle": "Chairman and CEO",
  "about": "As chairman and CEO of Microsoft, I define my mission and that of my company as empowering every person and every organization on the planet to achieve more.",
  "location": { "city": "Redmond", "state": "WA", "country": "US" },
  "seniority": { "totalExperienceYears": 12, "currentTenureYears": 12 },
  "experience": { "work": [ { "title": "Chairman and CEO", "company": "Microsoft", "startDate": "2014-02-01", "endDate": null } ] },
  "education": [ { "school": "University of Wisconsin-Milwaukee", "degreeName": "Master’s Degree", "fieldOfStudy": "Computer Science" } ]
}
```

*(trimmed for display — the card also carries `skills`, `languages`,
`certifications`, `inferredSalary`, social links and connection counts
whenever the profile has them)*

`fullOutput: true` upgrades every resolved name to the complete document —
**164 fields across 37 sections**, including full career history with
descriptions and the contact block.

The **Output tab** shows three views: *Overview*, *Career & education*,
and *Contacts & signals*.

### Pricing — you only pay for resolved names

| Event | Price | When |
|---|---|---|
| Name resolved (summary) | $0.0032 | exactly one profile matched, 60+ field row |
| Name resolved (full document) | $0.008 | `fullOutput: true`, 164 fields / 37 sections |
| Ambiguous / unknown / invalid | **$0** | always free, with the namesake count |

### FAQ

**Why did my name come back `ambiguous`?** More than one real person
carries it. The row tells you how many (`_nameMatchCount`) — add
`companyDomain` to anchor the name to an employer and rerun.

**What exactly does `fullOutput` add?** The complete career history with
role descriptions, education and certification detail, publications,
awards, related profiles — and the contact block. The summary card never
carries contact data.

### The family

Same engine, other doors: **Reverse Email Lookup** (email → person),
**Profile Lookup** (URL → profile), **Work Email Finder** (name + domain →
email), **Company Employees Finder** (domain → roster), **People/Company
Database Search**, **Social Handle Lookup** (dev/social handle → person),
**Bulk People Enrichment** (CSV, 50k rows). One data core, one billing
promise: misses are free.

### Disclaimer

This Actor is an independent product and is not affiliated with, endorsed
by, or sponsored by LinkedIn Corporation. It does not access, crawl, or
scrape LinkedIn at run time — answers come from our own database of
publicly available professional data; "LinkedIn" is used only to describe
the kind of public profile data the database covers. Removal requests are
honored via the Issues tab.

# Actor input Schema

## `names` (type: `array`):

One "First Last" name per line. Without a company domain, a name resolves only when exactly one profile carries it — namesakes come back as free "ambiguous" rows with the holder count.

## `companyDomain` (type: `string`):

Anchor every name to one employer's site domain (example: acme.com). Makes common names resolvable.

## `fullOutput` (type: `boolean`):

Return the complete profile document — 164 fields in 37 sections: full career history with role descriptions, education detail, certifications, publications, patents, awards, projects and all contact fields — instead of the 60+ field summary card. Ambiguous and unmatched names stay free in both modes.

## Actor input object example

```json
{
  "names": [
    "Satya Nadella"
  ],
  "companyDomain": "microsoft.com",
  "fullOutput": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "names": [
        "Satya Nadella"
    ],
    "companyDomain": "microsoft.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sputnikapi/name-to-profile").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "names": ["Satya Nadella"],
    "companyDomain": "microsoft.com",
}

# Run the Actor and wait for it to finish
run = client.actor("sputnikapi/name-to-profile").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "names": [
    "Satya Nadella"
  ],
  "companyDomain": "microsoft.com"
}' |
apify call sputnikapi/name-to-profile --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sputnikapi/name-to-profile"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gpEV6oY146rpfArxz/builds/rCw5FGPVK9m1R2xQq/openapi.json