# Clutch to LinkedIn Profile Finder (`creatorharsh/scrap-linkedinprofile-from-clutchdata`) Actor

Find LinkedIn profiles of Clutch reviewers using names, companies, job titles, and locations. Enrich your contact lists with profile URLs, confidence scores, and matching evidence.

- **URL**: https://apify.com/creatorharsh/scrap-linkedinprofile-from-clutchdata.md
- **Developed by:** [Harsh Vardhan](https://apify.com/creatorharsh) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

![Clutch to LinkedIn Profile Finder](https://api.apify.com/v2/key-value-stores/dPYPDciuTb0cf5HIJ/records/LinkedIn-ProfileScrapper.png?signature=cL0J9FnFMYa9EV4OQzn9)

### Clutch to LinkedIn Profile Finder

Clutch to LinkedIn Profile Finder takes a spreadsheet of people (name, company, job title and location) and finds each person's LinkedIn profile URL by searching Google's public results. For every person it returns the best matching `linkedin.com/in/` profile, a confidence score and label, the profile's headline, and the evidence behind the match, so you can trust the strong matches and check only the uncertain ones. It never logs in to LinkedIn and never scrapes LinkedIn pages: it reads public search results only.

It is built to pair with the [Clutch Reviews Scraper](https://apify.com/creatorharsh/clutch-reviews-scraper-extract-company-reviews-client-data): scrape reviewer names, positions and companies from Clutch.co, then upload that list here to get their LinkedIn profiles.

### Use cases

- B2B lead generation: turn reviewer or contact lists (name, company, title) into LinkedIn profile URLs ready for outreach
- LinkedIn prospecting: find decision makers at companies that appear in your CRM, review sites or event lists
- Lead enrichment: add a LinkedIn URL and current headline to existing prospect spreadsheets
- Recruiting and sourcing: locate candidate profiles from names and employers
- Data cleaning: confirm which contacts still match their listed company and role, using the `role_may_be_outdated` flag
- Market research: build structured contact lists for the people behind the companies you study

### How it works

1. Upload an Excel (`.xlsx`) or CSV file with one person per row.
2. For each person the Actor runs a Google search limited to LinkedIn profiles:\
   `site:linkedin.com/in Name,Title,Company,Location`\
   If that finds no profile with the person's name (for example because their profile no longer mentions the old title or company), it runs one more search: `site:linkedin.com/in "Name" Company`.
3. It keeps only `linkedin.com/in/` profiles whose title or URL shows the person's name. Nicknames (Debs / Deborah), accents (Loïc, Hægeland) and Cyrillic spellings are tolerated.
4. It scores each profile from what the search result shows and returns the best one.
5. Optionally, an AI model (OpenAI GPT-4o mini or Anthropic Claude Haiku) reviews cases with two or more candidate profiles. It never changes the result: if it disagrees with the evidence, the row is only flagged for review.

At most two searches are made per person, so a file of 100 people uses between 100 and 200 searches.

### Input

| Field | Required | Description |
|---|---|---|
| **People file** | Yes | An `.xlsx` or `.csv` file. The first sheet is used and row 1 must contain the headers. |
| **Use an LLM to disambiguate matches** | No | On by default. When a person has two or more candidate profiles, an AI model checks the choice and flags disagreements. |
| **LLM provider** | No | OpenAI (GPT-4o mini, default) or Anthropic (Claude Haiku). |

Download the sample file from the link at the top of the input form and replace its rows with your own.

#### File columns

| Column | Required | Example |
|---|---|---|
| Name | Yes | Jane Example |
| Company | Yes | Acme Widgets Ltd |
| Title | No | CEO |
| Location | No | London, England |

Column names are matched flexibly (for example "Reviewer Name", "Job Title" or "Company Name" also work). Rows without a name or company are skipped, and the log reports how many. More detail in the file (title and location) improves the match.

### Output

The Actor creates one result row per person, **in the same order as the rows in your uploaded file**, so you can paste the results next to your original list. You can download the dataset as Excel, CSV, JSON or HTML from the **Output** tab.

| Field | Description |
|---|---|
| `name`, `title`, `company`, `location` | The details from your file |
| `linkedin_url` | The best matching LinkedIn profile, or `null` if none was found |
| `confidence_score` | 0 to 100 |
| `confidence_label` | `High`, `Medium (check)` or `Low (manual review)` |
| `needs_review` | `true` for anything that is not High, for outdated roles, and for flagged rows |
| `query_used` | `main` or `fallback`: which search found the profile |
| `google_rank` | The profile's position in that search's Google results (1 is the top) |
| `current_role_hint` | The headline shown for the profile, which can reveal a newer role |
| `role_may_be_outdated` | `true` when the profile headline no longer shows the company from your file |
| `evidence_sources` | The result URL(s) behind the match |
| `note` | Extra information, for example "No LinkedIn profile matching the name was found in the search results." |

#### Example output

```json
{
  "name": "Jane Example",
  "title": "CEO",
  "company": "Acme Widgets Ltd",
  "location": "London, England",
  "linkedin_url": "https://www.linkedin.com/in/jane-example",
  "confidence_score": 80,
  "confidence_label": "High",
  "query_used": "main",
  "google_rank": 1,
  "needs_review": false,
  "role_may_be_outdated": false,
  "current_role_hint": "CEO at Acme Widgets Ltd",
  "evidence_sources": ["https://uk.linkedin.com/in/jane-example"],
  "note": ""
}
```

#### How to read the confidence

| Signal in the search result | Points |
|---|---|
| The company appears in the result | +40 |
| The profile is the top Google result (top 3) | +15 (+8) |
| The location matches | +15 |
| The job title matches (CEO, Founder and Managing Director count as the same) | +10 |
| The result names a different country | −30 (−10 if the company still matches) |

- **High (80 or more):** company, location, title and rank all agree. Safe to use.
- **Medium (60 to 79):** very likely right; a quick check is recommended.
- **Low (below 60):** the name matches, but the company or role was not confirmed. This is common for people who changed jobs. The URL is still returned so you can check it, and `needs_review` is `true`.

The Actor prefers an honest "needs review" over a confident wrong answer.

### Tips and limits

- **Not everyone has a public profile.** If a person has no LinkedIn profile that Google has indexed, the row is returned with `linkedin_url` set to `null`. In a test on 36 real Clutch reviewers, 31 (about 86%) returned a profile URL.
- **Common names need more detail.** Add the title and location to your file, and always check `Low` rows before using them.
- **Single-word names and handles** (for example a username instead of a real name) usually cannot be matched.
- **People who changed jobs** are found by the fallback search, but they get a lower confidence label because their profile no longer shows the old company. Check `current_role_hint` and `role_may_be_outdated`.
- **Search results vary slightly** from one run to the next, because Google's results change. Scores can move a few points.
- Use the **Output** tab filters to review `needs_review = true` rows first.

### Is it legal and ethical to use?

The Actor only reads publicly visible Google search results and does not access LinkedIn directly or bypass any login. The data it returns can include personal data (names, job titles and profile links). Use it only for a legitimate purpose, such as B2B outreach with a lawful basis, and follow the data protection laws that apply to you (for example GDPR) and LinkedIn's terms of service. If you are unsure, consult a legal professional.

### Support

Found a person who should have matched but did not? Open an issue on the Actor page and include the row from your file, the result you expected and the run ID.

# Actor input Schema

## `peopleFile` (type: `string`):

First sheet, headers in row 1. Required columns: Name, Company. Optional: Title, Location. .xlsx or .csv.

## `useLlmDisambiguation` (type: `boolean`):

When 2+ candidate profiles are found, ask an LLM which one it prefers. It never changes the result: if it disagrees with the evidence-based pick, the row is only flagged for review. The API key is configured by the Actor owner.

## `llmProvider` (type: `string`):

Which model to use when LLM disambiguation is enabled. The API keys are configured by the Actor owner.

## Actor input object example

```json
{
  "useLlmDisambiguation": true,
  "llmProvider": "openai"
}
```

# Actor output Schema

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

Default dataset with one item per person: name, title, company, location, linkedin\_url (null if not found), confidence\_score, confidence\_label, needs\_review and supporting fields. Download it as Excel, CSV, JSON or HTML.

# 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 = {
    "useLlmDisambiguation": true,
    "llmProvider": "openai"
};

// Run the Actor and wait for it to finish
const run = await client.actor("creatorharsh/scrap-linkedinprofile-from-clutchdata").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 = {
    "useLlmDisambiguation": True,
    "llmProvider": "openai",
}

# Run the Actor and wait for it to finish
run = client.actor("creatorharsh/scrap-linkedinprofile-from-clutchdata").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 '{
  "useLlmDisambiguation": true,
  "llmProvider": "openai"
}' |
apify call creatorharsh/scrap-linkedinprofile-from-clutchdata --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,creatorharsh/scrap-linkedinprofile-from-clutchdata"
        }
    }
}
```

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/fLShzM9F4967AgF7Q/builds/j5sijECDw37xRG9Sf/openapi.json