# LinkedIn Profile Candidate Finder — Google Indexed (`meka.im/linkedin-profile-candidate-finder`) Actor

Find likely LinkedIn profile candidates for people you already know using public Google-indexed identity signals. Get ranked candidates, confidence scores, and evidence for review. No LinkedIn account or cookies. $0.50 per 1,000 successful candidate sets.

- **URL**: https://apify.com/meka.im/linkedin-profile-candidate-finder.md
- **Developed by:** [Meka.im](https://apify.com/meka.im) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 delivered candidate sets

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

Find likely LinkedIn profile candidates for people you already know using public Google-indexed identity signals. Get ranked candidates, confidence scores, and matching evidence. No LinkedIn account or cookies. **Every result requires human review.**

- **Google-only discovery:** uses public Google-indexed web results without Bing, Brave, LinkedIn sessions, browsers, or people-data providers.
- **Auditable candidates:** returns canonical profile URLs, public result titles/snippets, scores, and explicit match reasons.
- **Honest outcomes:** Google gaps become `not_found`; invalid inputs and search failures remain distinct errors.
- **Delivered-only pricing:** **$0.50 per 1,000 successful candidate sets**. `not_found`, errors, and empty inputs are free. Platform usage is included.

### Quick start

```json
{
  "people": [
    {
      "fullName": "Satya Nadella",
      "company": "Microsoft",
      "domain": "microsoft.com",
      "title": "CEO",
      "location": "Redmond"
    }
  ],
  "maxCandidates": 5,
  "includeEvidence": true,
  "minScore": 40
}
```

Use public professional clues you already possess. More context can improve ranking, but no combination of clues turns a candidate into verified identity.

### What the results mean

Each input produces one ordered Dataset record:

- `candidate_found`: at least one canonical `linkedin.com/in/...` result reached the configured score;
- `not_found`: Google did not expose a candidate that reached the threshold;
- `error`: the item was invalid or its Google-only search failed.

`requiresReview` is set to `true` for every record. A high score means the public result matched more supplied clues; it is not proof that the profile belongs to the intended person.

```json
{
  "fullName": "Satya Nadella",
  "company": "Microsoft",
  "domain": "microsoft.com",
  "title": "CEO",
  "location": "Redmond",
  "status": "candidate_found",
  "bestCandidateUrl": "https://www.linkedin.com/in/satyanadella",
  "bestCandidateTitle": "Satya Nadella - Chairman and CEO at Microsoft - LinkedIn",
  "bestCandidateSnippet": "Public Google-indexed profile snippet...",
  "score": 100,
  "confidence": "high",
  "matchReasons": ["name matched", "company matched", "title matched"],
  "requiresReview": true,
  "source": "google_public_index",
  "queryCount": 1,
  "candidates": [
    {
      "url": "https://www.linkedin.com/in/satyanadella",
      "title": "Satya Nadella - Chairman and CEO at Microsoft - LinkedIn",
      "snippet": "Public Google-indexed profile snippet...",
      "score": 100,
      "confidence": "high",
      "matchReasons": ["name matched", "company matched", "title matched"]
    }
  ]
}
```

Google may return stale snippets or a profile belonging to a namesake. Review the URL, title, snippet, and supplied clues before using a result.

### Input reference

#### `people`

Required array of 1–1,000 known people. `fullName` is required. Optional `company`, `domain`, `title`, `location`, and `keywords` are used only as search and ranking clues.

The Actor executes at most three Google-only query variants per unique normalized input. Duplicate inputs share the same search work but retain their physical input positions.

#### `maxCandidates`

Returns 1–10 ranked candidates per successful input. The default is 5. One successful input costs one event regardless of whether it returns one or five candidates.

#### `includeEvidence`

Enabled by default. Disable it to omit result titles, snippets, and per-candidate match reasons while retaining canonical URLs and scores.

#### `minScore`

The default is 40. Raising it reduces candidate delivery and false positives, but cannot provide identity verification.

#### `maxConcurrency`

The conservative default is 5. Increasing it does not change the Google-only source or ranking semantics.

### Ordering, duplicates, errors, and recovery

Dataset records keep physical input order. Equivalent normalized inputs reuse their search result, while each input still receives its own record. Dataset contents are the recovery source of truth: a restarted run continues after the committed prefix and does not write or charge those records again.

`invalid_input` is separate from `search_failed`, and both are separate from a genuine `not_found`. The Actor never silently calls another search engine.

### Pricing and budget behavior

One `candidate_found` record triggers one `candidate-set-delivered` event at `$0.0005`:

| Successful candidate sets | Price |
|---:|---:|
| 100 | $0.05 |
| 1,000 | $0.50 |
| 10,000 | $5.00 |

`not_found`, errors, and empty input produce no delivery event. Platform usage is included. The Actor reserves the possible event charge before scheduling another input, so a run spending limit can stop processing before the next person starts.

### Coverage and limitations

- The Actor searches Google's public LinkedIn profile index only.
- It does not visit LinkedIn profile pages.
- It does not return full work history, contact details, private data, or identity verification.
- Google can omit profiles, retain stale snippets, or rank a namesake above the intended person.
- A profile not returned by Google becomes `not_found`; there is no hidden Bing, Brave, browser, account, or paid-data fallback.
- This is candidate discovery, not LinkedIn People Search, a verified resolver, or an outreach tool.

### API and automation

Use the same JSON through the Apify JavaScript or Python client, CLI, HTTP API, schedules, webhooks, Make, or Zapier. Dataset exports are available in JSON, JSONL, CSV, Excel, XML, and other Apify formats.

For automated review queues, filter for `status=candidate_found`, retain `requiresReview`, and send the evidence to a human reviewer rather than treating the score as verified identity.

### FAQ and troubleshooting

#### Why did a known person return `not_found`?

Google may not index that LinkedIn profile or may not expose enough public evidence for the configured threshold. The Actor does not substitute another source or guess a slug.

#### Why can a high score still be wrong?

Namesakes can share employer, title, or location terms. Scores summarize matching public text; they do not authenticate a person.

#### Does this scrape LinkedIn profiles?

No. It accepts public professional clues and ranks `linkedin.com/in/` URLs found in Google's public index. It does not open the candidate profiles.

#### Is this affiliated with LinkedIn or Google?

No. This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Google. Use public search evidence responsibly and comply with applicable laws and platform terms.

# Actor input Schema

## `people` (type: `array`):

One record per known person. A full name is required; company, domain, title, location, and keywords improve ranking.

## `maxCandidates` (type: `integer`):

Maximum ranked LinkedIn profile candidates returned for each successful input.

## `includeEvidence` (type: `boolean`):

Include Google result titles, snippets, and match reasons with each candidate.

## `minScore` (type: `integer`):

Higher thresholds return fewer candidates. A score is ranking evidence, not an identity-verification guarantee.

## `maxConcurrency` (type: `integer`):

Maximum people processed concurrently. The conservative default is validated for the Google-only route.

## Actor input object example

```json
{
  "people": [
    {
      "fullName": "Satya Nadella",
      "company": "Microsoft",
      "domain": "microsoft.com",
      "title": "CEO",
      "location": "Redmond"
    }
  ],
  "maxCandidates": 5,
  "includeEvidence": true,
  "minScore": 40,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `candidateSets` (type: `string`):

No description

## `runSummary` (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 = {
    "people": [
        {
            "fullName": "Satya Nadella",
            "company": "Microsoft",
            "domain": "microsoft.com",
            "title": "CEO",
            "location": "Redmond"
        }
    ],
    "maxCandidates": 5,
    "minScore": 40,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("meka.im/linkedin-profile-candidate-finder").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 = {
    "people": [{
            "fullName": "Satya Nadella",
            "company": "Microsoft",
            "domain": "microsoft.com",
            "title": "CEO",
            "location": "Redmond",
        }],
    "maxCandidates": 5,
    "minScore": 40,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("meka.im/linkedin-profile-candidate-finder").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 '{
  "people": [
    {
      "fullName": "Satya Nadella",
      "company": "Microsoft",
      "domain": "microsoft.com",
      "title": "CEO",
      "location": "Redmond"
    }
  ],
  "maxCandidates": 5,
  "minScore": 40,
  "maxConcurrency": 5
}' |
apify call meka.im/linkedin-profile-candidate-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,meka.im/linkedin-profile-candidate-finder"
        }
    }
}
```

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/DEUFT5A2tKkI9dVPl/builds/vFYPn39sAie6e7rTF/openapi.json