# Linkedin Profile Scraper with Email & Company Data (No Cookie) (`scraper-engine/linkedin-profile-scraper`) Actor LinkedIn Profile Scraper extracts public profile details, job titles, company information, locations, skills, and publicly available emails without requiring browser cookies. Build structured datasets for B2B lead generation, recruiting, prospecting, and market research. - **URL**: https://apify.com/scraper-engine/linkedin-profile-scraper.md - **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community) - **Categories:** - **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.99 / 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. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ### LinkedIn Profile Scraper — Emails, Company Data and Work History Linkedin Profile Scraper with Email & Company Data (No Cookie) turns a list of LinkedIn profile URLs or usernames into structured JSON: full name, work history, education, current-company details (domain, industry, headcount, website), and an optional SMTP-verified work email. No LinkedIn login or cookie is required. Every profile is pushed to the dataset the instant it finishes scraping, so results appear in the Output tab in real time. Paste your list of profiles below and start a run to see it in action. ### What is Linkedin Profile Scraper with Email & Company Data (No Cookie)? It's an Apify Actor that fetches LinkedIn's public, logged-out "guest view" pages for a list of profile URLs or usernames and parses them into a consistent JSON record per person — identity data, full experience and education history, and current-company enrichment pulled from the person's employer's own LinkedIn company page. No LinkedIn account, password, or session cookie is ever used — it is a pure HTTP scraper that never authenticates. It's built for recruiters, sales and growth teams doing lead enrichment, and developers or AI agents that need structured LinkedIn data without maintaining their own scraping or login infrastructure. ### What LinkedIn profile data is publicly available to scrape? LinkedIn exposes a real subset of a profile through its logged-out "guest view" pages — no sign-in required to load them at all. What isn't in that guest HTML is either behind a hard sign-in wall or only rendered after client-side JavaScript hydration in a real, authenticated browser session. | Data category | Public (guest view) | Restricted (needs login / hydrated session) | | --- | --- | --- | | Name, About preview, profile photo | Yes | — | | Current job title & company | Yes | — | | Full work experience & education | Yes | — | | Exact follower count | Yes | — | | Connection count | Yes, capped at LinkedIn's own "500+" display value | — | | Public posts/articles (used for the Featured section) | Yes | — | | Hand-authored headline text | — | Yes — only appears after client-side hydration in a signed-in browser | | Contact info (email, phone, personal sites) | — | Yes — hard sign-in wall | | Full connection list, DMs | — | Yes — login plus connection | Linkedin Profile Scraper with Email & Company Data (No Cookie) only returns publicly visible data — what any visitor sees without logging in. Nothing behind a login wall. The optional work-email field is a separate feature: a pattern-generated address verified live over SMTP against the company's own mail server, not something read out of LinkedIn's protected contact-info panel. ### What data can I extract with Linkedin Profile Scraper with Email & Company Data (No Cookie)? Every scraped profile returns identity data, full work history and education, current-company enrichment, network stats, and — when enabled — a verified work email, all in one flat JSON record. | Field name | Description | | --- | --- | | `fullname` | Full display name | | `first_name` | First name | | `last_name` | Last name | | `headline` | Always `null` — see the note below | | `about` | The profile's About/summary text (LinkedIn's own guest preview, truncated) | | `public_identifier` | The handle from `/in//` | | `username` | Same as `public_identifier` on success; the raw input value on a failed record | | `profile_url` | Canonical profile URL | | `profile_picture_url` | Profile photo URL | | `urn` | Numeric LinkedIn member URN | | `location` | Object: `city`, `country`, `country_code`, `full`, `postal_code` | | `connection_count` | Connection count (see cap above) | | `follower_count` | Exact follower count | | `current_company` | Current employer name (same value as `current_company_name`) | | `current_company_name` | Current employer name | | `current_company_url` | Current employer's LinkedIn company URL (same value as `current_company_linkedin_url`) | | `current_company_linkedin_url` | Current employer's LinkedIn company URL | | `current_company_domain` | Employer's website domain, parsed from their LinkedIn "About" page | | `current_company_website` | Employer's full website URL | | `current_company_description` | Employer's public description | | `current_company_industry` | Employer's industry | | `current_company_organization_type` | Employer's organization type (e.g. Nonprofit, Public Company) | | `current_company_headquarters` | Employer's headquarters location | | `current_company_employee_count` | Employer's exact employee count, as a string, when LinkedIn discloses it | | `current_company_followers` | Employer's LinkedIn follower count | | `current_company_urn` | Employer's LinkedIn organization URN | | `experience` | Array of roles: `title`, `company`, `duration`, `is_current`, `start_date`/`end_date` (year only), `company_id`, `company_linkedin_url`, `company_logo_url` | | `education` | Array of schools: `school`, `duration`, `start_date`/`end_date` (year only), `school_id`, `school_linkedin_url`, `school_logo_url` | | `featured` | Array of the person's public posts/articles: `title`, `description`, `image_url`, `social_counts` (`likes`, `comments`), `type`, `url` | | `email` | Discovered work email — only populated when `isEmailRequired` is enabled | | `is_email_valid` | Whether the email was SMTP-verified valid (`true`/`false`/`null` if unverifiable) | | `is_email_catch_all` | Whether the company's mail domain accepts any address (`true`/`false`/`null` if unverifiable) | | `valid` | `true` on a successfully scraped record | | `success` | `true` on a successfully scraped record | | `not_found` | `true` if LinkedIn returned a clean "Profile Not Found" page | | `error` | Present only on a failed record — e.g. `blocked_after_retries`, `invalid_input`, `http_` | | `input` | The raw value you passed in | #### Identity and profile fields `fullname`, `first_name`, `last_name`, `about`, `public_identifier`, `username`, `profile_url`, `profile_picture_url`, `urn`, and `location` describe who the person is and where they can be found on LinkedIn. ⚠️ `headline` is always returned as `null` — LinkedIn's guest pages never ship that hand-authored subtitle in raw HTML; it only appears after client-side JS hydration in a signed-in browser, so no logged-out scraper can return it. #### Network, company and email metrics `connection_count` and `follower_count` are the person's own network numbers. The `current_company_*` fields (name, domain, website, industry, organization type, headquarters, employee count, followers, URN) come from a follow-up fetch of the employer's own LinkedIn company page, cached once per unique company for the whole run. `is_email_valid` and `is_email_catch_all` are booleans (or `null` when SMTP verification couldn't run at all) describing the confidence of the returned `email`. #### 🤖 Add-on: Need additional LinkedIn data? If you need skills, honors, and a broader work-history sweep without email lookup, [LinkedIn People Profile Scraper](https://apify.com/store) covers that ground for the same no-login, no-cookie access model. For company-first lead lists with verified contact emails on a completely different platform, see [Shopify Store Leads Scraper — Emails, Phones & Ratings](https://apify.com/store). ### Why not build this yourself? LinkedIn's official APIs are partner-gated and scoped to data the authenticated member themselves grants access to — they are not a path to looking up an arbitrary third party's public profile the way this Actor does, so there's no meaningful official-API comparison to draw here. Building this in-house means: reverse-engineering the same guest-view HTML and embedded schema.org JSON-LD LinkedIn ships, maintaining a tiered proxy fallback so a single blocked request doesn't kill the whole run, tracking a guest cookie session by hand since LinkedIn's guest pages set them per request, and detecting LinkedIn's secondary "blurred-list" defense (real HTML that silently replaces experience/education text with asterisks) so you don't ship garbage data as if it were real. All of that is already implemented, tested, and maintained here. ### How to use Linkedin Profile Scraper with Email & Company Data (No Cookie) The Actor runs entirely on the Apify platform — no separate signup or API key is needed beyond your Apify account. 1. Open the Actor's page in the Apify Store and click **Try for free** (or **Start**, if you already have it saved). 2. Paste one or more LinkedIn profile URLs or bare usernames into the required `urls` field — one per line. 3. Optionally turn on **Find & verify a work email** (`isEmailRequired`), or open the Proxy settings section to force a specific proxy tier instead of the automatic default. 4. Click **Start**. 5. Read results from the **Dataset** tab as JSON or CSV, or open one of the five built-in views — Overview, Experience & Education, Company Data, Email & Contact, or Featured Content. #### How to scale to bulk profile extraction `urls` is an array (`stringList` editor), so bulk extraction is the default way this Actor works, not a separate mode — paste as many profile URLs or usernames as you need, one per line, in a single run. Profiles are processed with a fixed internal concurrency of 2 at a time; there is no separate "batch" input to configure. ### What can you do with LinkedIn profile data? - 🎯 A sales development rep building an outbound list uses `current_company_domain` and `email` to reach a prospect directly instead of guessing an inbox. - 🧑‍💼 A recruiter sourcing candidates uses `experience` and `education` to confirm a person's background matches a role before reaching out. - 📊 A market researcher tracking a company's team uses `current_company_name`, `current_company_employee_count`, and `follower_count` across many profiles to gauge a company's public footprint. - 🧩 A growth marketer building an enrichment pipeline feeds `fullname`, `current_company_name`, and `email` into a CRM to fill gaps left by other data providers. - 🤖 An AI agent or RAG pipeline indexes `about`, `experience`, and `education` as text context so an LLM can answer questions about a person's background without ever touching raw HTML. ### How does Linkedin Profile Scraper with Email & Company Data (No Cookie) handle rate limits and blocking? By default, every request goes straight to LinkedIn with no proxy at all. If LinkedIn rejects or bot-gates a request, the Actor automatically escalates through three tiers — no proxy → Apify Proxy datacenter → Apify Proxy residential — and, once it reaches residential, stays on residential for every remaining request in the run rather than dropping back down. Each profile page gets up to 5 attempts against this escalation ladder, with a randomized delay of roughly 0.7–1.6 seconds between requests and increasing backoff after each blocked attempt. A guest cookie session is warmed up once per proxy tier and reused across requests. If a profile is blocked on every attempt, the record is returned with `error: "blocked_after_retries"` rather than left out silently — this is reported distinctly from a genuine "profile not found." If the connection to LinkedIn itself is failing outright (not blocking, but not reaching LinkedIn at all — network or DNS issues), the run stops early after repeated consecutive failures rather than burning through the rest of the input. ⚠️ LinkedIn also runs a softer, second-layer defense on some requests: a normal, non-blocked page can still come back with individual experience or education entries replaced character-for-character with asterisks. The Actor detects this and leaves that entry's fields blank rather than pushing the masked text through as if it were real data. ### ⬇️ Input Only one field is required: `urls`. Everything else is optional. | Parameter | Required | Type | Description | Example value | | --- | --- | --- | --- | --- | | `urls` | Yes | array | One or more LinkedIn profile URLs or bare usernames to scrape, one per line. Bulk is supported. Company/school URLs are rejected — personal profiles only. | `["https://www.linkedin.com/in/williamhgates/", "satyanadella"]` | | `isEmailRequired` | No | boolean | When enabled, generates likely work-email candidates from the person's name and their current company's domain, then verifies them live over SMTP (with catch-all detection). Adds extra time per profile. Default: `false`. | `true` | | `proxyConfiguration` | No | object | Proxy tier configuration. By default the Actor uses no proxy and auto-escalates only if LinkedIn blocks a request; set this to force a specific tier (e.g. Residential) from the start instead. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` | #### Example input ```json { "urls": [ "https://www.linkedin.com/in/williamhgates/", "https://www.linkedin.com/in/satyanadella/" ], "isEmailRequired": true, "proxyConfiguration": { "useApifyProxy": false } } ``` ### ⬆️ Output Results are pushed to the Apify dataset one record per profile, the moment each profile finishes — you don't wait for the whole run to see data appear. Every record uses the same fixed set of keys, whether the profile scraped successfully or failed, so downstream code can rely on one consistent shape. Export the dataset as JSON, CSV, Excel, XML, or RSS directly from the Apify platform, or read it through the API or SDK. Every profile pushed — successful, not-found, or blocked — is charged as one `row_result` event; the only requests that are never pushed and never charged are ones dropped by the connectivity circuit-breaker described above, since nothing was actually scraped for those. #### Example output ```json { "about": "Co-chair of the Bill & Melinda Gates Foundation. Founder of Breakthrough Energy...", "connection_count": 500, "current_company": "Gates Foundation", "current_company_description": "The Gates Foundation is a nonprofit fighting poverty, disease, and inequity around the world.", "current_company_domain": "gatesfoundation.org", "current_company_employee_count": "1288", "current_company_followers": 245310, "current_company_headquarters": "Seattle, Washington", "current_company_industry": "Philanthropic Fundraising Services", "current_company_linkedin_url": "https://www.linkedin.com/company/gates-foundation", "current_company_name": "Gates Foundation", "current_company_organization_type": "Nonprofit", "current_company_url": "https://www.linkedin.com/company/gates-foundation", "current_company_urn": "2724968", "current_company_website": "https://www.gatesfoundation.org", "education": [ { "school": "Harvard University", "duration": "1973 - 1975", "start_date": { "year": 1973 }, "end_date": { "year": 1975 }, "school_id": null, "school_linkedin_url": "https://www.linkedin.com/school/harvard-university", "school_logo_url": null } ], "email": "bill.gates@gatesfoundation.org", "experience": [ { "title": "Co-chair", "company": "Gates Foundation", "duration": "2000 - Present", "is_current": true, "start_date": { "year": 2000 }, "end_date": null, "company_id": null, "company_linkedin_url": "https://www.linkedin.com/company/gates-foundation", "company_logo_url": null } ], "featured": [ { "title": "Why global health is a smart investment", "description": "Why global health is a smart investment", "image_url": "https://media.licdn.com/dms/image/featured-thumb.jpg", "social_counts": { "comments": 214, "likes": 18420 }, "type": "article", "url": "https://www.linkedin.com/pulse/why-global-health-smart-investment" } ], "first_name": "Bill", "follower_count": 41000000, "fullname": "Bill Gates", "headline": null, "is_email_catch_all": false, "is_email_valid": true, "last_name": "Gates", "location": { "city": "Seattle", "country": "United States", "country_code": "US", "full": "Seattle, Washington, United States", "postal_code": "" }, "not_found": false, "profile_picture_url": "https://media.licdn.com/dms/image/profile-photo.jpg", "profile_url": "https://www.linkedin.com/in/williamhgates", "public_identifier": "williamhgates", "urn": "urn:li:member:123456789", "valid": true, "input": "https://www.linkedin.com/in/williamhgates/", "username": "williamhgates", "success": true } ``` ### How does it work? The Actor loads LinkedIn's public, logged-out "guest view" pages the same way a signed-out visitor's browser would — a browser-impersonating HTTP client, not a headless browser, since these pages are plain server-rendered HTML. It parses two sources on each page: an embedded schema.org JSON-LD block LinkedIn ships for search engines (the highest-fidelity source for name, exact follower count, and job/education history), and structural DOM parsing for whatever that JSON-LD doesn't carry, like exact dates. If LinkedIn rejects or bot-gates a request, the Actor automatically routes around it by escalating through no-proxy, datacenter, and residential proxy tiers rather than failing the run. Only data that's genuinely publicly visible on the page is ever returned — nothing is guessed to fill a gap. Because the output schema is fixed by this Actor's own parsing logic rather than mirrored 1:1 off LinkedIn's page structure, the field names and shape you build against stay stable even as LinkedIn tweaks its layout. ### Integrations Linkedin Profile Scraper with Email & Company Data (No Cookie) runs on the Apify platform, so it works with anything that can call an Apify Actor: the REST API, official SDKs, an MCP server for AI agents, or no-code automation tools. #### Calling Linkedin Profile Scraper with Email & Company Data (No Cookie) programmatically ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("linkedin-profile-scraper-with-email-and-company-data").call( run_input={ "urls": ["https://www.linkedin.com/in/williamhgates/"], "isEmailRequired": True, } ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["fullname"], item["current_company_name"], item.get("email")) ``` Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request. #### MCP integration for AI agents This Actor is reachable through Apify's Actors MCP Server, which exposes any Apify Actor as a callable tool to MCP-compatible clients such as Claude Desktop, Claude Code, and Cursor: ``` npx -y @apify/actors-mcp-server --actors linkedin-profile-scraper-with-email-and-company-data ``` Point your MCP client at that server and it can call this Actor, pass it a list of profile URLs, and read back the dataset directly inside the agent's context. #### No-code tools (n8n, Make, LangChain) In n8n, use the Apify node (or a plain HTTP Request node) pointed at this Actor's run endpoint to trigger a scrape as a workflow step. In Make, the Apify app's "Run Actor" module starts a run and passes results into the rest of your scenario. In LangChain, `ApifyActorsTool` wraps this Actor's technical name so an agent can call it directly and receive dataset items as tool output. ### Is it legal to scrape LinkedIn profiles? Scraping publicly available LinkedIn profile data is generally lawful — the data returned by this Actor is limited to what LinkedIn already shows any signed-out visitor, not anything behind a login wall. Because a LinkedIn profile plus an inferred email address is personal data, GDPR (if you or your data subjects are in the EU/UK) and CCPA (for California residents) govern how you may store, process, and use it — you need a lawful basis for holding it and must honor deletion and access requests. Consult legal counsel if your use case involves bulk storage of personal data. ### Frequently asked questions #### What LinkedIn profile fields does this scraper return? The top fields are `fullname`, `current_company_name`, `experience`, `education`, and `follower_count`, alongside dozens more identity, company, and network fields — see the full field table above. #### Does this scraper require a LinkedIn account or login? No. It only reads LinkedIn's public, logged-out guest-view pages and never authenticates — no cookie, password, or session is used at any point. #### How many profiles can I extract in one run? As many as you paste into `urls` — it's an array input with no fixed maximum. Profiles are processed with an internal concurrency of 2 at a time. #### What happens if a profile is private or doesn't exist? The Actor detects LinkedIn's own "Profile Not Found" page and returns a record with `not_found: true`, `success: false`, and `valid: false` — this is reported separately from a blocked/bot-gated request, which instead comes back with `error: "blocked_after_retries"` so you can tell the two failure modes apart in code. #### Can I scrape multiple LinkedIn profiles at once? Yes — `urls` accepts a list, so pasting multiple URLs or usernames (one per line) scrapes all of them in a single run. #### Does this scraper require a LinkedIn session cookie (li\_at)? No. It never asks for or uses any LinkedIn cookie — every request goes through LinkedIn's public guest-view pages, which is what makes login-free operation possible in the first place. #### Does it work with Claude, ChatGPT, and other AI agent tools? Yes. It's reachable through Apify's Actors MCP Server for MCP-compatible clients, and callable as a standard HTTP endpoint by any agent framework that can make a request. #### Does it return data in a format LLMs can use directly? Yes — typed, normalized JSON with consistent field names across every run. No HTML parsing or CSS selectors required; pass records directly to an LLM, index them into a vector store, or feed them to an agent tool. #### What happens when LinkedIn changes its layout or anti-bot system? The Actor is actively maintained, and its output schema is designed to stay stable across LinkedIn layout changes since the field names come from this Actor's own parsing logic, not a 1:1 mirror of LinkedIn's page structure. #### Can I use this without managing proxies or browser infrastructure? Yes. Proxy selection and escalation (no proxy → datacenter → residential) and guest session handling are all managed automatically — you don't need to supply, rotate, or configure your own proxies unless you want to force a specific tier. #### Which fields work best for AI training data and RAG indexing? For RAG, index `about`, `experience`, and `education` — the highest-information free text and structured history. For training data, `fullname`, `current_company_name`, `follower_count`, and `connection_count` are the most consistently structured fields across records, all returned as typed primitives rather than free text. ### Related scrapers | Scraper | What it extracts | | --- | --- | | LinkedIn People Profile Scraper | Skills, honors, and full experience/education, no-login, without email lookup | | Naukri Job Scraper — India + Gulf, Emails & 41 Fields | Job postings from Naukri.com and Naukrigulf.com with employer email enrichment | | Shopify Store Leads Scraper — Emails, Phones & Ratings | Business leads with verified contact emails, phones, and ratings | | Twitter X Profile Viewer | Public X/Twitter profile bio, stats, and pinned tweets, no login required | ### Your feedback Found a bug or missing a field? Let us know at — reports and feature requests are read and actioned directly. # Actor input Schema ## `urls` (type: `array`): 👤 One or more LinkedIn profile URLs or bare usernames to scrape, e.g. https://www.linkedin.com/in/williamhgates/ or just williamhgates (bulk supported — one per line). Company/school URLs are rejected — personal profiles only. ## `isEmailRequired` (type: `boolean`): ✨ When enabled, the Actor generates likely work-email candidates from the person's name and their current company's domain, then verifies them live over SMTP (with catch-all detection) before returning the best match. Adds extra time per profile — leave off for the fastest runs. ## `proxyConfiguration` (type: `object`): 🌍 By default the Actor connects to LinkedIn with NO proxy for maximum speed. If LinkedIn rejects or blocks a request, it automatically escalates: ⚡ No proxy → 🏢 Datacenter proxy → 🏠 Residential proxy (retried up to 3 times) — then sticks with Residential for every remaining request in the run. Every escalation is logged clearly. You can also force a specific tier yourself here. ## Actor input object example ```json { "urls": [ "https://www.linkedin.com/in/williamhgates/", "https://www.linkedin.com/in/satyanadella/" ], "isEmailRequired": false, "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `overview` (type: `string`): Identity, location, current company, and network stats for every scraped profile. ## `experience` (type: `string`): Full work history and education for every scraped profile. ## `company` (type: `string`): Enriched current-company details (industry, size, HQ, website, domain) for every scraped profile. ## `email` (type: `string`): Discovered and SMTP-verified work email addresses (when enabled in input). ## `featured` (type: `string`): Best-effort featured posts/articles per profile. ## `fullRecord` (type: `string`): Every field, unfiltered, exactly as pushed to the dataset. ## `csv` (type: `string`): The full result set as a CSV file. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "urls": [ "https://www.linkedin.com/in/williamhgates/", "https://www.linkedin.com/in/satyanadella/" ], "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("scraper-engine/linkedin-profile-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "urls": [ "https://www.linkedin.com/in/williamhgates/", "https://www.linkedin.com/in/satyanadella/", ], "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("scraper-engine/linkedin-profile-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 '{ "urls": [ "https://www.linkedin.com/in/williamhgates/", "https://www.linkedin.com/in/satyanadella/" ], "proxyConfiguration": { "useApifyProxy": false } }' | apify call scraper-engine/linkedin-profile-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/linkedin-profile-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 ` 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/9aszNsJkbfmhxB10F/builds/8gJBjWbCbCSsfrQpK/openapi.json