# LinkedIn Profile Scraper with Email — No Cookies (`lergassy/linkedin-profile-email-scraper`) Actor

\[$3.20/1K profiles, $8/1K with e-mail] LinkedIn profile scraper with email: full public profile (title, company, experience with dates, education, skills, certifications) plus the person's work e-mail with evidence and confidence. E-mail price only when one is found. No cookies, no login.

- **URL**: https://apify.com/lergassy/linkedin-profile-email-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Lead generation, Marketing, Business
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.80 / 1,000 profile with e-mails

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper with Email** turns LinkedIn profile URLs into complete rows: the **full public profile** — name, headline, current title and company, location, about, followers, the whole experience history with dates, education, certifications, skills, recommendations — **plus the person's work e-mail address**, with the evidence behind it and a confidence level.

**$3.20 per 1,000 profiles, $8 per 1,000 profiles with e-mail** — and you pay the e-mail price **only when the row carries an e-mail at or above your minimum confidence** (default `medium`: the company's own site confirms the address layout). No LinkedIn login, no cookies, no account at risk, no start fee. Profiles that do not exist or that LinkedIn hides from logged-out visitors are free.

### What is LinkedIn Profile Scraper with Email?

A **LinkedIn email finder and profile scraper in one run**, for sales prospecting, recruiting and CRM enrichment. It reads the **public profile page** — the version LinkedIn shows search engines and logged-out visitors — and returns it as structured data. Then it turns the person's current company into its website, reads how that company writes its e-mail addresses (a team page that says `jane.doe@` tells you how everyone else is addressed), builds the person's address in that layout and checks that the mail domain accepts mail.

One row per person, one charge per row: **Profile with e-mail** when the row carries an address, **Profile** when it does not. Never both. No official LinkedIn API needed.

### What data does it extract?

| Field | Meaning |
|---|---|
| `fullName`, `firstName`, `lastName`, `headline` | Identity as shown on the profile |
| `title`, `company`, `companyLinkedinUrl`, `currentPositions` | Current role(s) with the company page |
| 📧 `email`, `confidence`, `emailStatus` | The work e-mail (only at or above **Minimum e-mail confidence**), `confirmed` / `high` / `medium` / `low`, and what was really checked: `found-on-website`, `pattern-confirmed` or `unverified-guess` (see below) |
| `emailGuess` | The best address when it is **not** put into `email` (below your minimum confidence, or the domain failed the DNS check) — free, use at your own risk |
| `emailDomainStatus` | DNS verdict for the mail domain: `accepts-mail`, `risky`, `undeliverable`, `unknown` |
| `emailPattern`, `foundOnSite`, `patternEvidence`, `patternEvidenceCount` | The layout used (`first.last`, `flast`, `first`…), whether the address itself is on the company site, and the published addresses that prove the layout |
| `alternatives` | Runner-up addresses in the other plausible layouts |
| `domain`, `domainSource`, `domainEvidence`, `companyWebsiteName` | The company website and how it was confirmed as the company's |
| `emailProvider`, `emailMxHost`, `emailIsRole`, `emailIsFree`, `emailIsDisposable` | Mail-domain checks: Google Workspace, Microsoft 365…, role / free / disposable flags |
| `summary` | One line: where the e-mail came from and how the row was charged |
| `location`, `country`, `about`, `website` | Location, about text, website from the profile |
| `city`, `region`, `countryCode` | The location split into parts (`Redmond` / `Washington` / `US`); city and region stay empty for a country-only or metro-area location |
| `followers`, `connections`, `badges` | Follower count, "500+" connections, Creator / Top Voice |
| `experience` | Every role, including each role inside a company group: title, company, company URL, `companyLogo`, `location`, `employmentType` (when shown), start, end, current flag, duration, full description |
| `education` | Every school with `degree`, `fieldOfStudy`, `activities`, `grade`, `description`, `schoolLogo`, start and end |
| `certifications`, `volunteering`, `publications`, `honorsAndAwards`, `organizations`, `skills`, `recommendations` | Every such section the public profile shows |
| `languages`, `languageProficiencies`, `courses`, `projects`, `testScores`, `coursesTaught` | Languages with proficiency, courses, projects, test scores, LinkedIn Learning courses the person teaches |
| `imageUrl`, `coverImageUrl`, `memberId`, `profileUrn` | Photo, cover image, LinkedIn member id and URN |
| `similarProfiles`, `sameNameProfiles` | "Other similar profiles" (LinkedIn's "People also viewed" rail as logged-out visitors see it, usually 10–20: name, headline as the card shows it, location, followers, URL, photo) and "Others named …" when shown — free leads, no extra charge |
| `latestPosts`, `articles` | With **Add the latest posts and articles** on: 5–9 recent posts and up to 10 articles |

The field names are the same as in our [LinkedIn Profile Scraper](https://apify.com/lergassy/linkedin-profile-scraper) (profile part) and [LinkedIn Email Finder](https://apify.com/lergassy/linkedin-email-finder) (e-mail part), so a pipeline built on either keeps working.

### 💰 How much does it cost to scrape LinkedIn profiles with email?

| Event | You pay for | FREE | BRONZE | SILVER | GOLD / PLATINUM / DIAMOND |
|---|---|---|---|---|---|
| **Profile with e-mail** | a row whose `email` is filled — confidence at or above your minimum (default `medium`) | $0.008 | $0.0076 | $0.0072 | $0.0068 |
| **Profile** | a row without an e-mail (a guess only in `emailGuess` counts as no e-mail), or e-mail search off | $0.0032 | $0.00304 | $0.00288 | $0.00272 |
| Error row, 404, profile hidden from logged-out visitors | — | **$0** | **$0** | **$0** | **$0** |

- **The e-mail price is paid only when there is an e-mail.** A person whose company has no findable website, an address on a domain that takes no mail or has no MX record, a domain that does not answer a DNS check after three tries, or an address below the minimum confidence you set — the row is delivered and charged as a plain **Profile** (the guess is kept in `emailGuess` and `alternatives`, except on a domain that takes no mail).
- **No address on an unconfirmed domain.** An address is built only on a domain with evidence that it is the company's: you gave it, it is the parent's mail domain (Microsoft AI → microsoft.com), the company's LinkedIn page links it, the domain spells the company name, or the website carries the company's name. A look-alike domain is listed in `unconfirmedDomains` and the row is a plain **Profile**. Titles and credentials in names (Dr., Gov., PhD, MBA, Jr., emojis, text after a comma or a pipe) are removed before the address is written, and a middle name is never glued into it: "John H. Cammack" is john.cammack@, while a surname with particles stays whole ("van der Berg", "de la Cruz").
- **Minimum e-mail confidence to pay for** (default `medium` since 5 October 2026): a `low` address — the most common layout, nothing on the company's site confirms it — goes to `emailGuess` instead of `email`, at the plain profile price. Set it to `low` to get such guesses in `email` and pay the e-mail price for them; `high` or `confirmed` to pay only for stronger evidence.
- Experience, education, skills, posts, alternatives, evidence and domain checks: included. No fee per run, no proxy charge.
- On Apify's free plan ($5 of monthly credit) that is about **620 profiles with e-mail** or **1,500 profiles** a month.

#### Bulk export: what 50,000 profiles actually cost

| Job: 50,000 LinkedIn profiles | This Actor | harvestapi/linkedin-profile-scraper | dev_fusion/Linkedin-Profile-Scraper |
|---|---|---|---|
| Profiles only | **$160** | $200 | — |
| Profiles + e-mail search | **$294** (e-mail on ~56% of rows — $8/1,000 for those, $3.20/1,000 for the rest) | $500 ($10/1,000 per e-mail **search**, found or not) | $500 ($10/1,000 rows) |

Prices from the Apify Store on 1 October 2026 (FREE tier). The e-mail share is what we measured on a test list of 25 real profiles on 1 October 2026: **14 of 25 rows (56%) carried an e-mail**. An address is delivered only on a domain we could confirm as the company's own (and whose mail domain has a working MX record) — a person whose company we cannot pin to its website gets a plain profile row instead of a guess. Yours will differ, and you only pay $8/1,000 for the rows that actually carry an address. Honest detail from the same list: all of those addresses were `low` confidence, because large employers (Microsoft was the most common one) publish no personal addresses on their websites. That measurement was made with the minimum confidence at `low`; since 5 October 2026 the default is `medium`, so such guesses come in `emailGuess` at the plain profile price and only addresses whose layout the company itself shows are charged as e-mails — on lists of large-company employees expect far fewer e-mail rows (and a lower bill).

#### Why some profiles come back as free error rows

Every profile is read through a residential address, a new one for each profile. About one profile in five is hidden from logged-out visitors on that route (LinkedIn answers HTTP 999 or a login wall). Hidden profiles are opened through a second route: a web unblocker first, and a heavier unblocking service for the ones it cannot open — together they open most of them, even on a short list made only of hidden profiles. The second route is paid from the run's own margin and is included in the price. What still refuses — usually profiles their owners hid from search engines — comes back as an error row and costs nothing. This Actor never logs in. On our 120-profile test list on 1 October 2026 all 120 profiles were delivered, 31 of them through the second route — expect a few percent of error rows on other lists.

#### Run health

When a run ends with many error rows, the Actor sends its developer the counts (rows delivered, error types, run ID) so the cause gets fixed fast. Your input and your results are never sent.

#### Very long lists

When most of the last 30 profiles in a run are refused by rate limits (hidden profiles do not count), the rest of the list goes straight to the second route (with your own proxies: the run pauses for 90 seconds, and after two pauses stops). A run that gets within 45 seconds of its timeout stops taking new profiles the same way. Profiles that were not tried are not charged; their URLs are saved in the `NOT_ATTEMPTED` record of the run's key-value store and named in the status message. With **Max cost per run** set, the run stops by itself at that amount, green, with every written row paid for.

### How to scrape LinkedIn profiles with email in three steps

1. Paste LinkedIn profile URLs or slugs into **👤 LinkedIn profiles** — `https://www.linkedin.com/in/satyanadella` or `satyanadella` — or link a file / Google Sheet.
2. Leave **📧 Find the work e-mail** on. Optionally raise **Minimum e-mail confidence to pay for**, or set **Company override** when the whole list works at one company.
3. Press **Start**, then download JSON, CSV or Excel — or call it from the API, n8n, Make, Zapier or an AI agent.

### ⬇️ Input

```json
{
  "profileUrls": ["https://www.linkedin.com/in/satyanadella", "jeffweiner08", "justinwelsh"],
  "findEmail": true,
  "minConfidence": "medium",
  "includePosts": false
}
```

#### Input options

| Field | Default | What it does |
|---|---|---|
| `profileUrls` | 3 demo profiles | Profile URLs or slugs |
| `startUrls` | — | A file or Google Sheet with profile URLs |
| `findEmail` | `true` | Find the work e-mail; off = profiles only at the Profile price |
| `minConfidence` | `medium` | Lowest confidence put into `email` and paid at the e-mail price; weaker guesses go to `emailGuess` |
| `companyOverride` | — | One company name or domain for everyone |
| `candidatesPerPerson` | 3 | How many addresses (best + alternatives) |
| `maxPagesPerCompany` | 4 | Company pages read to learn the address layout |
| `checkMx` | `true` | DNS check that the mail domain accepts mail — always runs, because only an address on a domain with an MX record is charged as an e-mail |
| `includePosts` | `false` | Latest posts and articles in the row, no extra charge |
| `maxItems`, `concurrency`, `pageTimeoutSecs`, `proxyConfiguration` | | Limits and network settings |

### ⬆️ Output

```json
{
  "type": "profile",
  "fullName": "Justin Welsh",
  "firstName": "Justin",
  "lastName": "Welsh",
  "headline": "Writer & Entrepreneur. I write The Saturday Essay for 200,000+ ambitious people…",
  "title": "Writer",
  "company": "the saturday essay.",
  "email": null,
  "confidence": "low",
  "emailStatus": "unverified-guess",
  "domain": "thesaturdayessay.com",
  "emailGuess": "justin.welsh@thesaturdayessay.com",
  "emailDomainStatus": "accepts-mail",
  "companyLinkedinUrl": "https://www.linkedin.com/company/saturday-essay",
  "location": "New York City Metropolitan Area",
  "city": null,
  "region": null,
  "countryCode": "US",
  "followers": 883050,
  "connections": "500+",
  "experience": [
    { "title": "Writer", "company": "the saturday essay.", "startDate": "Jan 2022", "endDate": null, "current": true, "duration": "4 years 10 months", "companyLogo": "https://media.licdn.com/dms/image/v2/…", "location": null, "employmentType": null },
    { "title": "Founder", "company": "Justin Welsh", "startDate": "Aug 2019", "endDate": null, "current": true, "duration": "7 years 3 months", "companyLogo": "https://media.licdn.com/dms/image/v2/…", "location": null, "employmentType": null }
  ],
  "education": [{ "school": "The Ohio State University", "startDate": "1999", "endDate": "2003", "degree": "BSBA", "fieldOfStudy": "Marketing", "activities": "Phi Kappa Tau Fraternity, Project Open Hand, Economics Tutor" }],
  "coverImageUrl": "https://media.licdn.com/dms/image/v2/…",
  "memberId": "16259454",
  "similarProfiles": [{ "name": "Will Polese", "headline": "ELSA, Corp", "location": "Bali, Indonesia", "followers": 8000, "linkedinUrl": "https://www.linkedin.com/in/willpolese", "imageUrl": null }],
  "sameNameProfiles": [],
  "linkedinUrl": "https://www.linkedin.com/in/justinwelsh",
  "emailPattern": "first.last",
  "emailPatternSource": "default",
  "foundOnSite": false,
  "alternatives": [
    { "email": "justin.welsh@thesaturdayessay.com", "pattern": "first.last" },
    { "email": "justin@thesaturdayessay.com", "pattern": "first" },
    { "email": "jwelsh@thesaturdayessay.com", "pattern": "flast" }
  ],
  "patternEvidence": [],
  "emailProvider": "godaddy",
  "summary": "Best guess justin.welsh@thesaturdayessay.com (unverified-guess) is \"low\" confidence, below the minimum you set (\"medium\"); it is in \"emailGuess\" and \"alternatives\". Charged as a plain profile.",
  "scrapedAt": "2026-10-01T14:44:09.901Z"
}
```

#### What the confidence levels and statuses mean

| `confidence` | `emailStatus` | What was checked | In `email` by default? |
|---|---|---|---|
| **confirmed** | `found-on-website` | the address itself is published on the company website | yes — Profile with e-mail |
| **high** | `pattern-confirmed` | two or more personal addresses on the company site use this layout | yes — Profile with e-mail |
| **medium** | `pattern-confirmed` | one personal address on the company site uses this layout | yes — Profile with e-mail |
| **low** | `unverified-guess` | nothing: the most common corporate layout (`first.last`) on a domain that accepts mail | no — `emailGuess`, plain Profile price |
| **unusable** | `undeliverable` / `risky` / `unknown` | the mail domain failed the DNS check | no — plain Profile price |

Until 5 October 2026 every address on a domain with an MX record was labelled `deliverable`. That label is gone: the DNS result is in `emailDomainStatus` and `emailMxHost`, and it says only that the **domain** takes mail, not that this mailbox exists.

Mailbox-level (SMTP) verification is deliberately not done: it is unreliable for Google and Microsoft domains and gets senders blocked. If you need it, run the `email` column through an e-mail verifier.

### Use cases for LinkedIn profile and e-mail data

#### Outbound from a LinkedIn search

Export a search, paste the profile URLs, get title, company, career history and a work e-mail per person in one row — ready for a sequence.

#### Recruiting

The full career path with tenure per role, and an address to write to the candidate outside LinkedIn InMail.

#### CRM enrichment

Refresh contacts on a schedule: job changes show up as a new current company, and the e-mail follows the new domain.

#### AI agents

Through the Apify MCP server an agent can ask *"who is this person and how do I reach them?"* and get one row back, with `summary` explaining the e-mail.

### Integrations

Every run is available through the Apify API (JavaScript and Python clients), and the Actor works out of the box with n8n, Make, Zapier, Google Sheets, LangChain, webhooks and the Apify MCP server.

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lergassy/linkedin-profile-email-scraper").call(run_input={
    "profileUrls": ["https://www.linkedin.com/in/satyanadella"], "minConfidence": "medium"})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row.get("fullName"), row.get("email"), row.get("confidence"))
```

### ❓ FAQ

#### How is this different from harvestapi or dev_fusion?

Same idea — LinkedIn profiles plus e-mail without cookies — at a lower price: $3.20 vs $4 per 1,000 plain profiles and $8 vs $10 per 1,000 profiles with e-mail. The bigger difference is **what you pay for**: harvestapi charges $10/1,000 for every e-mail *search*, and dev_fusion $10/1,000 for every row; here the e-mail price applies only to rows that actually carry an address, and every address comes with its evidence and a confidence level.

#### Do I need cookies or a LinkedIn account?

No. It reads public profiles only, so nothing can be restricted.

#### Why does a profile come back without an e-mail?

The profile lists no current company, the company has no website we can find (use **Company override** with its domain), the domain takes no mail, LinkedIn shows only the initial of the surname ("Diego C.") so the address cannot be written, or the best address is below your minimum confidence (then it is in `emailGuess`). Those rows cost the plain Profile price.

#### Why is `email` empty but `emailGuess` filled?

The company's website shows no personal address that confirms the layout, so the address is only the most common corporate layout — a guess (`emailStatus: unverified-guess`). It is not charged as an e-mail. Set **Minimum e-mail confidence to pay for** to `low` if you want such guesses in `email` (and pay the e-mail price for them).

#### What happens to an input that is not a profile URL?

It comes back as a free error row (`type: "error"`) that names the value, instead of being skipped silently.

#### Do I only need profiles, or only e-mails?

Profiles only: [LinkedIn Profile Scraper](https://apify.com/lergassy/linkedin-profile-scraper). E-mail only, without the full profile: [LinkedIn Email Finder](https://apify.com/lergassy/linkedin-email-finder). This Actor is both in one row.

#### Is one row returned per profile?

Yes — one row per profile URL, one charge per row, duplicates in the input are read once.

#### Can I use it with the Apify API or an MCP server?

Yes. Call it from the API or the JavaScript / Python client, or let an AI agent call it through the Apify MCP server.

#### Can I integrate it with other apps?

Yes — n8n, Make, Zapier, Google Sheets, webhooks and anything that speaks HTTP.

#### Is it legal to scrape LinkedIn profiles and e-mails?

The Actor reads profiles that people have made public and builds business addresses from public company websites. The rows are personal data: under GDPR, CCPA and similar laws you need a lawful basis to process them, must respect opt-outs and anti-spam rules (CAN-SPAM, PECR), and must follow LinkedIn's terms. Use it for legitimate business purposes only; when in doubt, consult a lawyer.

### Your feedback

Something missing or wrong in a row? Open an issue on the Issues tab — it gets answered fast. A review helps other buyers find the Actor.

### You might also like

| Actor | What it does |
|---|---|
| [LinkedIn Profile Scraper](https://apify.com/lergassy/linkedin-profile-scraper) | The same profiles without the e-mail step, $2–3 per 1,000 |
| [LinkedIn Email Finder](https://apify.com/lergassy/linkedin-email-finder) | Work e-mail from a profile URL, paid per e-mail found |
| [LinkedIn Company Scraper](https://apify.com/lergassy/linkedin-company-scraper) | Company pages: size, industry, website, HQ |
| [LinkedIn Posts Scraper](https://apify.com/lergassy/linkedin-posts-scraper) | Posts and articles of people and companies |

# Changelog

This Actor's version history is a separate document: https://apify.com/lergassy/linkedin-profile-email-scraper/changelog.md

# Actor input Schema

## `profileUrls` (type: `array`):

LinkedIn profile URLs or slugs, one per line — <b>https://www.linkedin.com/in/satyanadella</b> or <b>satyanadella</b>. One row per profile. Profiles that do not exist or are hidden from logged-out visitors are free.

## `startUrls` (type: `array`):

The same thing for long lists — upload a file or link a Google Sheet (or any text/CSV URL) that contains LinkedIn profile URLs.

## `findEmail` (type: `boolean`):

Find each person's work e-mail: company website, the address layout it uses, mail-domain check, confidence. A row WITH an e-mail is charged as 'Profile with e-mail'; a row without one is charged as a plain 'Profile'. Switch off to get profiles only.

## `minConfidence` (type: `string`):

Below this level the address is NOT put into 'email': it goes to 'emailGuess' (and 'alternatives') and the row is charged as a plain profile. low = most common layout, nothing confirms it (emailStatus unverified-guess); medium = the company's own site uses this layout (pattern-confirmed); high = 2+ addresses on the site confirm it; confirmed = the address is published on the site (found-on-website). No mailbox (SMTP) check is made.

## `companyOverride` (type: `string`):

Use this company name or domain for everyone instead of what the profiles say — handy when all profiles work at one company, or when a company name cannot be turned into a website.

## `candidatesPerPerson` (type: `integer`):

The best address goes into 'email'; runners-up go into 'alternatives'.

## `maxPagesPerCompany` (type: `integer`):

Home page plus contact / team / about pages, to learn how the company writes its addresses.

## `checkMx` (type: `boolean`):

DNS MX check. It always runs, because it decides the charge: only an address on a domain with an MX record is delivered as an e-mail. A domain without an MX record, one that takes no mail, or one that does not answer DNS after three tries leaves the row a plain profile.

## `includePosts` (type: `boolean`):

The person's recent posts (usually 5–9) and articles (up to 10) inside the same row. No extra charge.

## `maxItems` (type: `integer`):

A hard ceiling on what one run reads and bills.

## `concurrency` (type: `integer`):

How many profiles to read at the same time. Keep it low — LinkedIn dislikes bursts.

## `pageTimeoutSecs` (type: `integer`):

How long to wait for one company web page before giving up on it.

## `proxyConfiguration` (type: `object`):

Residential, a new address for every profile — included in the price, nothing to set up. LinkedIn blocks direct and datacenter requests after a few dozen profiles, so those settings are ignored. Company websites are read directly. Only your own proxy URLs replace this (then the second route for refused profiles is off).

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella",
    "https://www.linkedin.com/in/jeffweiner08",
    "justinwelsh"
  ],
  "startUrls": [],
  "findEmail": true,
  "minConfidence": "medium",
  "companyOverride": "",
  "candidatesPerPerson": 3,
  "maxPagesPerCompany": 4,
  "checkMx": true,
  "includePosts": false,
  "maxItems": 10000,
  "concurrency": 3,
  "pageTimeoutSecs": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per profile: current role, experience, education, skills, plus work e-mail, confidence and layout evidence.

## `runSummary` (type: `string`):

JSON summary of the run: rows delivered, rows filtered out, failed inputs (free) and request statistics.

## `notAttempted` (type: `string`):

JSON list of inputs the run did not reach (time limit or "Max cost per run"). Not charged — pass them as input to a new run to continue. Present only when the run stopped early.

# 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 = {
    "profileUrls": [
        "https://www.linkedin.com/in/satyanadella",
        "https://www.linkedin.com/in/jeffweiner08",
        "justinwelsh"
    ],
    "minConfidence": "medium",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/linkedin-profile-email-scraper").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 = {
    "profileUrls": [
        "https://www.linkedin.com/in/satyanadella",
        "https://www.linkedin.com/in/jeffweiner08",
        "justinwelsh",
    ],
    "minConfidence": "medium",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/linkedin-profile-email-scraper").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 '{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella",
    "https://www.linkedin.com/in/jeffweiner08",
    "justinwelsh"
  ],
  "minConfidence": "medium",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call lergassy/linkedin-profile-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/linkedin-profile-email-scraper"
        }
    }
}
```

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/Ej688LPvwfEI3kev6/builds/7AUGsuIIDwAf58GGx/openapi.json