# Profile Details Batch Scraper for LinkedIn + EMAIL (No Cookies) (`data_wiki/profile-details-batch-scraper-for-linkedin-email-no-cookies`) Actor

Scrape public LinkedIn profiles in bulk and get one clean record per person: name, headline, location, followers, jobs, education, certifications, languages, company details and a work email lookup. No cookies or login. Great for lead generation, recruiting and CRM enrichment.

- **URL**: https://apify.com/data_wiki/profile-details-batch-scraper-for-linkedin-email-no-cookies.md
- **Developed by:** [Data WiKi](https://apify.com/data_wiki) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🚀 What is Profile Details Batch Scraper for LinkedIn + EMAIL?

Profile Details Batch Scraper for LinkedIn + EMAIL is an Apify Actor and a LinkedIn profile batch scraper. Paste a list of public profile links, usernames or `in/` paths and it returns one record per person: experience, education, employer details, career insights and a work email lookup. No cookies or login are needed.

- **Bulk list input:** a LinkedIn bulk profile scraper run starts from one list, and duplicates are removed before anything is read.
- **Saved as it goes:** every finished profile is written to the dataset at once, so a long run never loses completed work.
- **No cookies, no login:** the Actor reads pages any visitor can open. If you looked for a LinkedIn profile scraper no cookies option, the input has no cookie or login field.
- **A record of where data came from:** the `source` option lets the Actor fill hidden or missing sections from earlier public copies of the same page, and `data_source` shows which part came from where.
- **Email lookup on by default:** this LinkedIn scraper with email lookup takes an address from the profile or a listed website when one is published, and otherwise may infer one.

Click **Try for free**, paste your profiles and press **Start**.

### 📊 What data can you extract from LinkedIn?

As a LinkedIn profile details scraper, the Actor saves one record per profile with up to 21 top-level sections. Export the dataset as JSON, CSV, Excel, XML or HTML. A section stays empty when the public page does not show it, and masked text is never written to the output.

| Field | Description | Example |
|---|---|---|
| `basic_info` | Name, headline, location, follower and connection counts, current company and title, top school, websites, picture links, badges, about text and `email` | `{"fullname": "Dana Sample"}` |
| `experience` | One entry per job with title, company, employment type, location, dates, tenure and description | `{"title": "Operations Manager"}` |
| `education` | Schools with degree, field of study and dates | `{"school": "Sample City University"}` |
| `languages`, `certifications` | Languages with proficiency, and certifications with issuer, date and credential | `[]` |
| `volunteering`, `projects`, `publications`, `honors_and_awards`, `patents`, `courses`, `test_scores`, `organizations`, `services` | Optional sections that appear only when the profile lists them | `[]` |
| `recommendations` | Recommendation count and received recommendations | `{"received": []}` |
| `insights` | Estimates worked out by the Actor from titles and dates: total experience, tenure, `seniority_level`, `department`, `highest_degree`, `profile_completeness_pct` | `"manager"` |
| `company_details` | Current employer: name, website, domain, industry, size, headquarters, type, founded and follower count. Present when employer details are on | `{"industry": "Logistics"}` |
| `email_info` | `email`, `email_status`, `email_confidence`, addresses found on the profile and on websites, candidates, company domain and mail provider. Present when the email lookup is on | `"pattern_guess"` |
| `activity`, `similar_profiles` | Recent posts, articles and taught courses with likes and comments, and the similar profiles shown on the page. Present when posts and similar profiles are on | `[]` |
| `data_source` | Where each section came from, which sections are still masked, and whether the page was the latest one | `{"is_fresh": true}` |

The Storage tab also offers table views for overview, experience, education, certifications, languages, volunteering, email, employer, insights, activity and similar profiles. The `insights` values are the Actor's own estimates and not data that LinkedIn publishes.

The `company_details` block holds LinkedIn company data for the current employer only. The `email_info` block is the LinkedIn profile email extractor part of each record. As a LinkedIn profile data extractor, the Actor can only return what a logged-out visitor sees, so expect empty sections on some profiles.

### 💡 Use cases for LinkedIn profile data

- **Lead lists:** use it as a LinkedIn lead generation tool for people you already picked, with `current_title`, `current_company` and `email` in one table. You can also build a prospect list from LinkedIn links your team collected.
- **Sales prospecting:** read `insights.seniority_level` and `department` to turn a sales prospecting list from LinkedIn into a shortlist your reps can check by hand.
- **B2B enrichment:** B2B lead enrichment adds `company_details` and a work email to contacts you already hold. LinkedIn contact enrichment works the same way, one profile link per contact.
- **CRM clean-up:** match rows on `profile_url` to enrich CRM contacts with LinkedIn data such as headline, location and employer. LinkedIn profile enrichment of an existing sheet then needs only the links.
- **Recruiting research:** candidate sourcing from LinkedIn starts with `experience`, `education` and `insights.highest_degree` for people you already know. Candidate research from LinkedIn profiles then reads as structured rows instead of open tabs.
- **Employer research:** employer research from LinkedIn profiles combines `company_details.industry`, `company_size` and `headquarters` with the people who work there.
- **Research datasets:** build a dataset of LinkedIn professionals from `experience`, `education` and `insights` for labour-market or career-path analysis.
- **AI inputs:** LinkedIn profile data for AI is easier to use as JSON with `data_source` attached, because a model or a vector store can see which parts were masked.

### 🛠️ How to scrape LinkedIn profiles in a batch

Follow these steps to scrape LinkedIn profiles from a list.

1. Create a free [Apify account](https://console.apify.com/sign-up) and open the Actor in Apify Console.
2. Paste your profiles into **Profile URLs or usernames**, one per line. A LinkedIn profile scraper from URL run accepts full links, `in/` paths and plain usernames.
3. Keep **Find email addresses** on to find email from LinkedIn profile URL lists, or switch it off.
4. Set **Include employer details** and **Include posts and similar profiles**, and choose a **Data freshness** option.
5. Click **Start** and watch the log. Each profile appears in the Output tab as soon as it is saved.
6. Open the Overview table and download it as CSV to get a LinkedIn profile to CSV file with one row per person. Other formats work from the same dataset.

### 💰 How much does it cost to scrape LinkedIn?

Pricing is pay per event: you pay for each profile the Actor saves to the dataset, and nothing for profiles that fail. Apify platform usage is billed on top of the events.

- **Result** (`main_result`): charged once for every saved profile.
- **Actor start** (`apify-actor-start`): $0.00005 per run. The Actor is set to 1024 MB of memory, which is one GB, so the start fee is one event.

| Apify plan tier | Price per 1,000 saved profiles |
|---|---|
| Free | $4.00 (0.004 x 1,000) |
| Bronze | $3.60 (0.0036 x 1,000) |
| Silver | $3.20 (0.0032 x 1,000) |
| Gold and above | $2.80 (0.0028 x 1,000) |

Example: 500 profiles on the Gold tier cost 500 x $0.0028 = $1.40 plus the $0.00005 start fee. The same 500 profiles on the Free tier cost 500 x $0.004 = $2.00 plus the start fee.

You can set a maximum spend per run. The Actor then stops cleanly and keeps the profiles already saved. See the Pricing tab for current rates.

### ⬇️ Input

Only **Profile URLs or usernames** (`urls`) is required. The input of this LinkedIn batch profile scraper has no field for a maximum number of profiles, so every valid line in the list is processed. Open the Input tab for every option.

This example uses two fictional profiles:

```json
{
  "urls": [
    "https://www.linkedin.com/in/sample-profile-a",
    "sample-profile-b"
  ],
  "includeEmail": true,
  "includeCompanyDetails": true,
  "includeActivity": false,
  "source": "auto",
  "proxyConfiguration": { "useApifyProxy": false }
}
```

- `urls`: LinkedIn profile links, `in/` paths or usernames. Duplicates are removed.
- `includeEmail`: look for a work email for each profile. The default is `true`.
- `includeCompanyDetails`: add details of the current employer. The default is `true`.
- `includeActivity`: add recent posts, articles, taught courses and similar profiles. The default is `true`.
- `source`: `auto` (the default) reads the latest public page and fills hidden or missing parts from earlier public copies. `live` uses only the latest page and `archive` uses only earlier copies.
- `proxyConfiguration`: proxy settings. The run starts without a proxy and switches to a proxy when requests are rejected.

> 💡 Start with two or three profiles to check the output before you run a long list.

> ⚠️ A link to a company page, a post or a search is not a profile link. It is skipped and listed in the run summary.

### ⬆️ Output

The scraped results are shown as a dataset in the **Storage** tab. The table view is for convenience and does not show **all the fields**. You can export LinkedIn profile data as JSON, CSV, Excel, XML or HTML. The results of this LinkedIn profile information extractor then open in your own tools.

This is a fictional, shortened record for the first profile of the input above. It does not describe a real person:

```json
{
  "basic_info": {
    "fullname": "Dana Sample",
    "headline": "Operations Manager at Northwind Sample Ltd",
    "public_identifier": "sample-profile-a",
    "profile_url": "https://www.linkedin.com/in/sample-profile-a",
    "current_company": "Northwind Sample Ltd",
    "current_title": "Operations Manager",
    "email": "dana.sample@northwind-sample.example"
  },
  "experience": [
    { "title": "Operations Manager", "company": "Northwind Sample Ltd", "is_current": true }
  ],
  "education": [
    { "school": "Sample City University", "degree": "Bachelor's degree" }
  ],
  "insights": { "seniority_level": "manager", "department": "operations", "highest_degree": "bachelor" },
  "company_details": {
    "name": "Northwind Sample Ltd",
    "domain": "northwind-sample.example",
    "industry": "Logistics"
  },
  "email_info": {
    "email": "dana.sample@northwind-sample.example",
    "email_status": "pattern_guess",
    "email_confidence": "medium",
    "emails_found_on_profile": [],
    "emails_found_on_websites": [],
    "company_domain": "northwind-sample.example",
    "mail_provider": "microsoft_365"
  },
  "data_source": { "primary": "live", "live_status": "profile", "is_fresh": true }
}
```

The second profile could not be read, so it is not in the dataset and not charged. It appears in the `RUN_SUMMARY` record of the key-value store:

```json
{
  "totalProcessed": 2,
  "totalSaved": 1,
  "totalFailed": 1,
  "failedUsernames": ["sample-profile-b"],
  "failureReasons": {
    "sample-profile-b": "profile not found on LinkedIn (404); no saved copy of this profile is available"
  },
  "unfinished": []
}
```

#### How to read the email fields

`email_status` tells you how an address was reached, and it is the field to read before you use any address:

- `found_on_profile` and `found_on_personal_website`: the address is written in the profile text or on a website listed on the profile.
- `pattern_guess`: the Actor inferred the address from the person's name and the employer's domain. It can be wrong and nothing confirms it exists.
- `domain_has_no_mail_server`, `only_generic_emails_found` and `not_found`: no personal address could be returned, so `email` is `null`.

The Actor sends no email, and none of the addresses are verified. `email_confidence` is a label per outcome, not a probability. To find work email by name and company domain, the Actor needs the first and last name from the profile and a company domain. The Actor works as a work email finder only for people you already listed. To find email address from LinkedIn profile pages, switch on **Find email addresses**. As a LinkedIn email finder tool it returns at most one address per profile. Think of the email part as a LinkedIn email scraper for published addresses plus an inferred fallback.

### ⚠️ Limitations and error handling

- The Actor reads only public pages as a visitor, so private, login-only and contact-hidden data is never collected. Because it is a LinkedIn scraper no cookies tool, it sees the logged-out view and some sections stay empty.
- It needs profile links, usernames or `in/` paths. As a LinkedIn profile extractor it does not search LinkedIn for people.
- It is a LinkedIn data scraper for person profiles and the current employer's public page. It is not a LinkedIn company data scraper for whole companies.
- Without a search function it is no bulk LinkedIn profile finder: you supply the list.
- Earlier public copies can be older than the latest page. `data_source.profile_as_of` and `is_fresh` show how current a record is.
- Pages are read at a measured pace and several profiles at a time. If LinkedIn keeps rejecting requests, the Actor skips fresh pages for the rest of the run and, with `source` set to `auto`, uses earlier copies instead. Run a short test to see how long your list takes.
- A long list may need more than one run, because a run has a time limit set in its options.
- Profiles that cannot be read are not saved and not charged. The reason is stored in `failureReasons` of the `RUN_SUMMARY` record:

| Reason in `RUN_SUMMARY` | Meaning | What to do |
|---|---|---|
| `not a LinkedIn profile username or URL` | The line is not a profile reference | Fix the line and run again |
| `profile not found on LinkedIn (404)` | The profile is not available | Check the link |
| `LinkedIn rejected the request on every connection tried` | The page kept refusing requests | Try again later |
| `fresh page skipped after repeated rejections` | The latest page was skipped after many refusals | Try again later or use `auto` |
| `LinkedIn showed a login wall` | The page asked for a login | Try again later |
| `no saved copy of this profile is available` | No earlier copy exists to fill the gap | Nothing, or try the latest page later |
| `saved copies exist but none is a readable profile page` | Earlier copies were not usable | Try again later |
| `network unavailable` | Requests did not reach a server | Run again |
| `internal error while processing (...)` | The profile crashed the parser | Report it in the Issues tab |

The run status message reads `Done - N profile(s) saved.` on success, `No profiles saved - LinkedIn did not return readable pages. See RUN_SUMMARY for the reasons.` when nothing was saved, and `Spend limit reached` when your maximum cost per run stopped the run.

### 🔌 Integrating Profile Details Batch Scraper for LinkedIn + EMAIL with other apps

You can run the Actor from the [Apify API](https://docs.apify.com/api/v2), on a [schedule](https://docs.apify.com/actors/running/schedules), or from webhooks that fire when a run finishes. Ready-made code samples are in the API tab. The [Apify integrations](https://docs.apify.com/integrations) connect the dataset to Make, Zapier, Google Sheets, Slack and Airbyte.

You can run this LinkedIn profile scraper online from Apify Console with nothing to install. Teams that need a LinkedIn profile data API for their own app can start runs and read the dataset items over HTTP. To start a run, send a request to `https://api.apify.com/v2/actors/data_wiki~profile-details-batch-scraper-for-linkedin-email-no-cookies/runs`.

Schedule a run to refresh the same list. Each run writes a new dataset, so you compare runs yourself. As a LinkedIn profile data scraper it writes one dataset item per profile, which suits spreadsheets and databases. Export the dataset to a sheet or a file to feed your talent sourcing tools or your CRM. For AI agents, the hosted [Apify MCP server](https://docs.apify.com/mcp) at `https://mcp.apify.com` lets an agent find the Actor with `search-actors`, read it with `fetch-actor-details` and run it with `call-actor`.

### 🔗 Other scrapers for LinkedIn and employer research by data_wiki

Only the first Actor below reads LinkedIn. The others relate by workflow: they add company websites, technology and employer data around the people you research.

| Actor | What it extracts | When to use it |
|---|---|---|
| [LinkedIn Profile Scraper + Email](https://apify.com/data_wiki/linkedin-profile-scraper-email-no-cookies) | Public LinkedIn profiles with a `maxProfiles` limit, a `compareWith` option and 61 fields | You want a profile Actor with the options listed in its own README, see the FAQ below. |
| [Contact Details Scraper](https://apify.com/data_wiki/contact-details-scraper) | Emails, phone numbers, social links and addresses from company websites | You have the employer's website and want its published contact details. |
| [BuiltWith Official Technology Scraper](https://apify.com/data_wiki/builtwith-official-technology-scraper) | Technologies, hosting and contacts of any website | You research which companies use a technology before you look at their people. |
| [Glassdoor Reviews & Jobs Scraper](https://apify.com/data_wiki/glassdoor-reviews-jobs-scraper) | Employee reviews, salaries, interviews and jobs per company | You want the employer side of a hiring or sales research. |

For help with runs, see the [Apify documentation](https://docs.apify.com/).

### ⚖️ Is it legal to scrape LinkedIn?

The Actor collects only information that a visitor can see on [LinkedIn](https://www.linkedin.com) without logging in, and it does not collect private or login-only data. That does not make every use lawful. The records contain personal data: names, job history, photos, locations and email addresses that are either published or inferred.

- **You decide the purpose.** You need a lawful basis to collect and store the data, for example under GDPR or CCPA, and you must handle access and deletion requests.
- **Outreach rules apply.** Anti-spam and e-privacy laws cover any message you send. An inferred address may belong to someone else or not exist.
- **Check the site's terms.** LinkedIn's terms may restrict automated collection, and you carry that risk.
- **Collect less.** Turn off the parts you do not need, and delete data you no longer use.

Questions such as LinkedIn scraping legal limits have no single answer, because they depend on your country and purpose. This is not legal advice, and the Actor makes no promise that your use is lawful. Talk to a lawyer if you are unsure. See Apify's posts on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical web scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/).

### ❓ FAQ

#### How does the LinkedIn profile batch scraper handle a large list?

It processes several profiles at a time with a short pause between page requests, and saves each profile as soon as it is ready. The input has no maximum, so the limits are your spend limit and the run time limit. Run a short test first to see how long your list takes.

#### Can I scrape LinkedIn profiles without login?

Yes. The Actor needs no login, account or cookies. The trade-off is that you only get the view a logged-out visitor sees, so some sections can be empty or masked.

#### Can you scrape LinkedIn profiles that are private?

No. Private and login-only profiles are not collected. Such a profile is skipped and listed in the run summary with a reason.

#### How accurate is the LinkedIn email finder part?

Treat any `pattern_guess` address as inferred, not confirmed. The Actor builds the address from the person's name and the employer's domain, so it can be wrong. Addresses with the status `found_on_profile` or `found_on_personal_website` were published, but you should still check them before outreach.

#### How do I find work email from LinkedIn profile links?

Paste the links, keep **Find email addresses** on and read `email_info.email_status` for each profile. The employer's domain comes from the employer details, so leave **Include employer details** on for best results. The Actor sends no email.

#### Can I find someone's work email with this Actor?

Only for a profile you give it. The Actor does not search by name. It reads the profile you list and then returns a published address, an inferred one, or `null`.

#### Is there a LinkedIn profile scraper API?

Yes. You can start the Actor and read its dataset through the Apify API. It is not an official LinkedIn profile API: it reads the same public pages a visitor can open.

#### Which LinkedIn profile Actor should I use?

Both Actors read public LinkedIn profiles without a login. This one takes a list only, has no maximum-profiles input, has a `source` option and returns 21 snake_case sections, and profiles that fail are listed in the run summary. The other one, [LinkedIn Profile Scraper + Email with run comparison](https://apify.com/data_wiki/linkedin-profile-scraper-email-no-cookies), has a `maxProfiles` input and a `compareWith` option, returns 61 camelCase fields including `skills`, and reports a status for each input. Choose the one whose output fields and options match your task.

#### Do I need proxies?

No. The run starts without a proxy and switches to a proxy when requests are rejected. You can set proxy settings in the input. Proxy traffic, if used, counts as Apify platform usage.

#### Can I use it through an MCP server?

Yes. Use the hosted Apify MCP server at `https://mcp.apify.com`, where an agent can search for the Actor, read its details and call it with the input above.

### 💬 Your feedback

Found a bug or need another field? Open an issue in the Issues tab of the Actor. Need a custom solution? Contact hello.datawiki@gmail.com.

# Changelog

This Actor's version history is a separate document: https://apify.com/data_wiki/profile-details-batch-scraper-for-linkedin-email-no-cookies/changelog.md

# Actor input Schema

## `urls` (type: `array`):

One LinkedIn profile per line: a full URL (https://www.linkedin.com/in/satyanadella), a short path (in/satyanadella) or just the username (satyanadella). Add as many as you like; duplicates are removed.

## `includeEmail` (type: `boolean`):

Look for a work email: addresses published on the profile and the person's websites, plus the most likely company-format address when the company's domain accepts mail. Pattern-based addresses are marked as guesses and are not mailbox-verified.

## `includeCompanyDetails` (type: `boolean`):

Add details of the current employer: website, domain, industry, size, headquarters, type and founding year.

## `includeActivity` (type: `boolean`):

Add recent posts, articles and taught courses with likes and comments, plus the list of similar profiles.

## `source` (type: `string`):

Automatic reads the latest public page and fills any hidden or missing parts from earlier public copies. The other two options use only one of these.

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

Requests start without a proxy. If they are rejected, the Actor retries with a datacenter proxy and then a residential proxy, and keeps using the residential proxy for the rest of the run.

## Actor input object example

```json
{
  "urls": [
    "satyanadella",
    "https://www.linkedin.com/in/neal-mohan"
  ],
  "includeEmail": true,
  "includeCompanyDetails": true,
  "includeActivity": true,
  "source": "auto",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All profiles, overview table.

## `experience` (type: `string`):

One row per job.

## `education` (type: `string`):

One row per school.

## `email` (type: `string`):

Email lookup result per profile.

## `summary` (type: `string`):

Totals, failed profiles and reasons.

# 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 = {
    "urls": [
        "satyanadella",
        "https://www.linkedin.com/in/neal-mohan"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_wiki/profile-details-batch-scraper-for-linkedin-email-no-cookies").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 = {
    "urls": [
        "satyanadella",
        "https://www.linkedin.com/in/neal-mohan",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_wiki/profile-details-batch-scraper-for-linkedin-email-no-cookies").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 '{
  "urls": [
    "satyanadella",
    "https://www.linkedin.com/in/neal-mohan"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_wiki/profile-details-batch-scraper-for-linkedin-email-no-cookies --silent --output-dataset

```

## MCP server setup

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

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/eDoZlgIdOxglugOMn/builds/hl3IICoURqkRBTWGi/openapi.json