# LinkedIn Profile Scraper — Public Profile Data Extraction (`herus13/linkedin-profile-scraper`) Actor

Extract public profile data from LinkedIn without login. Gets name, headline, experience, education, skills, certifications, languages, and more.

- **URL**: https://apify.com/herus13/linkedin-profile-scraper.md
- **Developed by:** [bootforge](https://apify.com/herus13) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 record scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 — Cookie-based Deep Profile Extraction

Scrape LinkedIn profile data with structured fields: name, headline, about, full experience history (reverse-chronological), education, skills, honors, projects, certifications, and optional contact info (email, phone, websites, twitter). Cookie-required — works on Apify residential proxy where no-cookie scrapers hit the authwall.

### How to Scrape LinkedIn Profiles

- **Reliable on Apify residential proxy** — paste your `li_at` cookie, get data. No-cookie scrapers can't access LinkedIn from cloud infrastructure anymore.
- **No surprise platform fees** — single-line per-event pricing, all-in.
- **Cookie persistence** — `cookie_persist_key` stores the cookie in *your own* per-account Apify KV store. Paste once, reuse across runs. We never see your credentials.
- **Resume cache** — re-running the same URLs hits cache, you only pay for new work.
- **Compass-friendly proxy config** — Apify residential, Bright Data, Oxylabs, SmartProxy, or raw URLs.
- **Open source** — inspect the parser, no black box.

### Why a cookie is required

LinkedIn now serves an authwall (`HTTP 999` + login redirect) to anonymous requests from cloud IPs. Apify residential proxies are widely used and frequently flagged. Empirically: anonymous requests against any LinkedIn profile URL from Apify infrastructure return zero data. A `li_at` cookie bypasses this gate.

Other LinkedIn scrapers that claim "no cookie required" either:
- Run their own clean residential pools (not Apify), or
- Charge customers for runs that return mostly empty data.

Our actor is honest: cookie-required, predictable output, fair pricing.

### ⚠️ Critical setup — proxy country MUST match your cookie's country

**LinkedIn ties session validity to IP geography.** Your `li_at` cookie was issued to a session in a specific country (the country you live / sign in from). If you proxy through a different country, LinkedIn flags it as a session hijack and **deauthorizes the cookie within 1-2 requests** — you'll get HTTP 401 on every profile.

**Always set `proxy.country` to the same country as your cookie.**

| Where you sign into LinkedIn | Your `proxy.country` |
|---|---|
| United States | `US` |
| United Kingdom | `GB` |
| Vietnam | `VN` |
| Germany | `DE` |
| Japan | `JP` |
| etc. | (matching ISO-3166 code) |

```json
"proxy": { "provider": "apify", "group": "RESIDENTIAL", "country": "US" }
````

If `country` is unset, Apify rotates IPs across all geos for every request — guaranteed deauth. The actor logs a loud warning when it detects this, but the right fix is to set the country in your input.

### How to get your LinkedIn cookie

1. Sign into LinkedIn in your normal browser
2. Open DevTools (F12 / Cmd+Opt+I)
3. **Application** tab → **Storage** → **Cookies** → `https://www.linkedin.com`
4. Find the `li_at` row → copy the **Value** column
5. Paste into the `cookie` field of this actor's input
6. **Note your sign-in country** — that's the value you set in `proxy.country` (see above)

Cookies typically last ~1 year. If a run starts returning 401s, the most common causes (in order): (1) `proxy.country` doesn't match your cookie's home geo, (2) cookie expired — paste a fresh one.

### What You Get

Structured fields per profile (only present fields populate; missing sections stay empty):

**Always populated when LinkedIn ships them:**

- `name`, `headline`, `about`, `profile_photo_url`
- `experience` (reverse-chronological, with company/title/location/start\_date/end\_date/description)
- `education` (school, degree, field of study, years)
- `current_company`, `current_title`, `location` (derived from your current job)
- `premium`, `influencer` badges

**Populated when LinkedIn ships them on your target profile (varies by privacy / completeness):**

- `industry`, `connection_count_numeric`, `follower_count`
- `open_to_work`, `verified`
- `skills` (full list), `skill_endorsements` (per-skill counts)
- `certifications`, `languages`, `volunteer`
- `honors`, `publications`, `patents`, `projects`, `courses`, `organizations`, `test_scores`

**Optional contact-info enrichment** (`scrape_contact_info: true`):

- `email`, `phones[]`, `websites[]`, `twitter[]`, `ims[]`, `birthday`, `address`, `interests[]`

### Quick Start

#### Single profile

```json
{
  "profile_urls": ["https://www.linkedin.com/in/williamhgates/"],
  "cookie": "<your_li_at_cookie>",
  "proxy": { "provider": "apify", "group": "RESIDENTIAL", "country": "US" }
}
```

#### With contact info enrichment

```json
{
  "profile_urls": ["https://www.linkedin.com/in/alice-walker-1234/"],
  "cookie": "<your_li_at_cookie>",
  "scrape_contact_info": true,
  "proxy": { "provider": "apify", "group": "RESIDENTIAL", "country": "US" }
}
```

#### Cookie persistence (paste once, reuse forever)

Tired of pasting the cookie every run? Set `cookie_persist_key` and the actor stores it in your *own* Apify Key-Value Store (named `linkedin-profile-scraper-cookies`, scoped to your account — we never see it).

**First run** — provide both `cookie` and `cookie_persist_key`:

```json
{
  "profile_urls": ["https://www.linkedin.com/in/williamhgates/"],
  "cookie": "<your_li_at_cookie>",
  "cookie_persist_key": "main",
  "proxy": { "provider": "apify", "group": "RESIDENTIAL", "country": "US" }
}
```

**Subsequent runs** — omit `cookie`, the actor reads from your KV:

```json
{
  "profile_urls": ["https://www.linkedin.com/in/jeffweiner08/"],
  "cookie_persist_key": "main",
  "proxy": { "provider": "apify", "group": "RESIDENTIAL", "country": "US" }
}
```

**Refresh** when a cookie expires — provide a new `cookie` value alongside the same key, and it overwrites the saved copy.

**Multiple LinkedIn accounts** — use different keys (`alice`, `bob`, `team-shared`, etc.).

### Sample Output

```json
{
  "public_identifier": "alice-walker-1234",
  "request_id": "5b1f4d2e3c8a4f6b9e7d2a1c8b4d6e9f",
  "status": "ok",
  "error": null,
  "profile_url": "https://www.linkedin.com/in/alice-walker-1234/",
  "name": "Alice Walker",
  "headline": "VP Engineering at TechCo",
  "location": "Boston, MA",
  "industry": "Software",
  "profile_photo_url": "https://media.licdn.com/...",
  "about": "Builder of teams and systems...",
  "connection_count_numeric": 1234,
  "follower_count": 56789,
  "open_to_work": false,
  "premium": true,
  "verified": true,
  "current_company": "TechCo",
  "current_title": "VP Engineering",
  "experience": [
    {"company": "TechCo", "title": "VP Engineering", "location": "Boston, MA", "start_date": "Mar 2022", "end_date": "Present", "description": "..."},
    {"company": "PrevCo", "title": "Director", "location": "NYC, NY", "start_date": "Jan 2018", "end_date": "Feb 2022"}
  ],
  "education": [
    {"school": "Stanford", "degree": "MS", "field_of_study": "Computer Science", "start_year": "2014", "end_year": "2016"}
  ],
  "skills": ["Python", "Distributed Systems", "Leadership"],
  "honors": [{"title": "Forbes 30 Under 30", "issuer": "Forbes", "issued_on": "Mar 2022"}],
  "projects": [{"title": "Open-source ANN library", "url": "https://github.com/alice/ann"}],
  "contact": {
    "email": "alice@techco.com",
    "phones": [{"number": "+1-555-0100", "type": "MOBILE"}],
    "websites": [{"url": "https://alice.dev", "category": "PERSONAL"}],
    "twitter": ["alicewalker"]
  },
  "scraped_at": "2026-05-05T12:00:00+00:00"
}
```

### Input Parameters

| Parameter | Default | Description |
|---|---|---|
| `profile_urls` | required | LinkedIn profile URLs **or** bare vanity slugs. Both `https://www.linkedin.com/in/williamhgates/` and `williamhgates` work; mix freely in the same list |
| `cookie` | **required** | Your `li_at` cookie. Either inline, or seed once via `cookie_persist_key` |
| `cookie_persist_key` | null | Optional. Reuse a cookie across runs by storing it in your own per-account Apify KV |
| `scrape_contact_info` | false | Fires `profileContactInfo` per profile — adds email, phones, websites, twitter, IM |
| `proxy` | null | Proxy config — **set `country` to match cookie's home geo** |
| `max_concurrency` | 5 | Concurrent profile requests |
| `max_requests_per_minute` | 30 | Rate cap to avoid LinkedIn throttling |
| `cache_provider` | memory | `memory`, `apify`, or `none` |
| `cache_ttl_seconds` | 3600 | Cache TTL for re-runs |

### Pricing

Two tiers, billed only on success. **No charge for blocked, failed, or not-found rows** — they still appear in the dataset (for traceability) but never trigger a profile event.

| Tier | What you get | Per profile | 1,000 profiles\* |
|---|---|---|---|
| **Tier 1 — Profile** | Full structured profile (experience, education, skills, certifications, honors, projects, languages, etc.) | **$0.007** | **$7.02** |
| **Tier 2 — Profile + Contact** | Tier 1 fields + emails, phones, websites, twitter, IM, birthday, address (when the profile shares them) | **$0.007 + $0.003** | **$10.02** |

\* Includes the $0.02 per-run start charge.

**Adaptive billing rules** (you only pay when we deliver):

- A profile that returns `status="blocked"` / `"not_found"` / `"failed"` is **never billed**.
- Tier 2 only adds the $0.003 contact-info charge **when contact data is actually returned**. Private profiles, profiles that don't share contact info, or sessions where the contact endpoint fails — all cost zero extra.

| Competitor | Mode | 1,000 profiles |
|---|---|---|
| dev\_fusion | Basic + email | $10.00 |
| HarvestAPI Profile Search | Full + email | ~$14 |
| **Us — Tier 1** | Full structured fields | **$7.02** |
| **Us — Tier 2** | + email/phone enrichment | **$10.02** |

| Competitor | Mode | 1,000 profiles |
|---|---|---|
| dev\_fusion | Basic + email | $10.00 |
| HarvestAPI Profile Search | Full + email | ~$14 |
| **Us — standard** | Full structured fields | **$7.02** |
| **Us — with contact** | + email/phone enrichment | **$10.02** |

### Proxy Configuration

LinkedIn aggressively rate-limits datacenter IPs. **Residential proxy is mandatory, and the `country` MUST match your cookie's home country** (see the Critical Setup section at the top). Replace `US` with your country in every example below.

```json
// Apify managed proxy (recommended)
{ "provider": "apify", "group": "RESIDENTIAL", "country": "US" }

// Bright Data
{ "provider": "brightdata", "username": "USER", "password": "PASS", "zone": "residential", "country": "US" }

// Oxylabs
{ "provider": "oxylabs", "username": "USER", "password": "PASS", "proxy_type": "residential", "country": "US" }

// SmartProxy
{ "provider": "smartproxy", "username": "USER", "password": "PASS", "proxy_type": "residential", "country": "US" }
```

**Mismatched country = deauthorized cookie.** Don't skip the `country` field.

### Error Handling

| Situation | What happens |
|---|---|
| No cookie + no persist key | Actor fails fast with clear message — no charge for failed run |
| Cookie expired / invalid | Voyager API returns 401; row emitted with `status="blocked"`, **not billed** |
| Profile doesn't exist | Row emitted with `status="not_found"`, **not billed** |
| Unparseable input string | Row emitted with `status="failed"` and the offending input in `profile_url`, **not billed** |
| Cookie geo ↔ proxy country mismatch | LinkedIn deauthorizes session, returns 401 — fix by matching `proxy.country` to your account |
| Profile is private | Public-readable fields populate; private sections stay empty |
| Residential IP timeout | Auto-retry on the next IP from a 5-IP rotation pool |
| Contact info hidden / private | Profile result still returned without `contact`; no billing for the contact event |
| Rate-limited (429 / 503) | Exponential backoff + jitter, up to 3 attempts |

### Frequently Asked Questions

**Can I scrape without a cookie?**
Not reliably from Apify or any cloud infrastructure. LinkedIn's authwall now requires authentication for anonymous cloud-IP requests. The actor will fail fast if you don't provide one.

**Will my cookie get my account banned?**
LinkedIn flags accounts that pull thousands of profiles per hour. Stick under the default `max_requests_per_minute: 30` and `max_concurrency: 5` for sustainable use. The Voyager endpoint is the same one the LinkedIn web app uses, so request shape isn't a flag — volume and cadence are.

**How long does a cookie last?**
Typically 1 year. If runs start failing with 401, paste a fresh cookie.

**How fresh is the cache?**
Default 1 hour. Re-running the same `profile_urls` within that window returns cached results without re-scraping or re-charging.

**Will all the rich fields populate on every profile?**
No — depends on what the profile owner has filled in and their privacy settings. Skills, honors, projects, certifications, languages etc. only show when the person added them. Numeric connection counts and badges populate when LinkedIn ships them on that profile (varies). Core fields (name, headline, about, experience, education) almost always populate.

**What about LinkedIn's terms of service?**
Cookie-mode requires *your* LinkedIn account credentials and is your responsibility. We don't store the cookie outside your own Apify KV (and only if you opt into `cookie_persist_key`).

### Related Actors

Building a full data pipeline? Pair this actor with our other scrapers — same proxy config format, same Pydantic-validated output, all open source.

#### Lead generation

- **[Google Maps Business & Contact Scraper](https://apify.com/herus13/google-maps-scraper)** — Scrape Google Maps businesses with emails, phone numbers, reviews, images, social links. 24 fields per business.

#### Lead generation / Hiring

- **[LinkedIn Jobs Scraper](https://apify.com/herus13/linkedin-jobs-scraper)** — Scrape LinkedIn job listings with 30 fields per job — company enrichment, salary, recruiter info, full description. No login required.

#### E-commerce intelligence

- **[TikTok Shop Product Scraper](https://apify.com/herus13/tiktok-shop-scraper)** — Scrape TikTok Shop products across 10 regions (US, GB, VN, TH, PH, MY, SG, JP, MX, BR) — variants, prices, seller info, ratings, sold counts.

# Actor input Schema

## `profile_urls` (type: `array`):

List of LinkedIn profile URLs to scrape (e.g. https://www.linkedin.com/in/username)

## `cookie` (type: `string`):

Your LinkedIn <code>li\_at</code> session cookie. <strong>Required</strong> — LinkedIn now serves an authwall to anonymous requests from cloud infrastructure (Apify residential included), so a cookie is the only reliable way to access profile data. Find it in your browser: DevTools → <strong>Application</strong> → <strong>Cookies</strong> → <code>linkedin.com</code> → <code>li\_at</code> → copy the value. Set <code>cookie\_persist\_key</code> below to avoid pasting it every run.

## `cookie_persist_key` (type: `string`):

Optional. When set, the actor reads/writes the <code>li\_at</code> cookie from your <strong>own</strong> Apify Key-Value Store (named <code>linkedin-profile-scraper-cookies</code>, scoped to your account). On first run, paste the <code>cookie</code> field too — it's saved under this key for future runs. Subsequent runs can omit <code>cookie</code> and just set this key to reuse the saved value. Use different keys for different LinkedIn accounts (e.g. <code>alice</code>, <code>bob</code>). The cookie never leaves your Apify account.

## `scrape_contact_info` (type: `boolean`):

When enabled <em>and</em> a cookie is supplied (either inline or via persist key), fetches the profileContactInfo endpoint per profile (1 extra LinkedIn request each). Returns email, phone, websites, twitter handles, IM contacts, birthday, address. Ignored when no cookie is available.

## `proxy` (type: `object`):

<strong>The <code>country</code> field is mandatory and must match the country where you normally sign into LinkedIn (the country your cookie was generated in).</strong> Examples: <code>US</code> if you sign in from the United States, <code>GB</code> from the United Kingdom, <code>VN</code> from Vietnam, <code>DE</code> from Germany, <code>JP</code> from Japan. <br><br>Without a matching country, LinkedIn flags the request as a session hijack and deauthorizes the cookie within 1-2 requests — every profile returns HTTP 401. <br><br>Datacenter proxy will not work — LinkedIn blocks the entire DC IP range. Always use <code>RESIDENTIAL</code>.

## `max_concurrency` (type: `integer`):

Maximum concurrent requests

## `max_requests_per_minute` (type: `integer`):

Rate limit for requests

## Actor input object example

```json
{
  "profile_urls": [
    "https://www.linkedin.com/in/williamhgates/"
  ],
  "scrape_contact_info": false,
  "proxy": {
    "provider": "apify",
    "group": "RESIDENTIAL",
    "country": "US"
  },
  "max_concurrency": 5,
  "max_requests_per_minute": 30
}
```

# 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 = {
    "profile_urls": [
        "https://www.linkedin.com/in/williamhgates/"
    ],
    "proxy": {
        "provider": "apify",
        "group": "RESIDENTIAL",
        "country": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("herus13/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "profile_urls": ["https://www.linkedin.com/in/williamhgates/"],
    "proxy": {
        "provider": "apify",
        "group": "RESIDENTIAL",
        "country": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("herus13/linkedin-profile-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "profile_urls": [
    "https://www.linkedin.com/in/williamhgates/"
  ],
  "proxy": {
    "provider": "apify",
    "group": "RESIDENTIAL",
    "country": "US"
  }
}' |
apify call herus13/linkedin-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=herus13/linkedin-profile-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Scraper — Public Profile Data Extraction",
        "description": "Extract public profile data from LinkedIn without login. Gets name, headline, experience, education, skills, certifications, languages, and more.",
        "version": "0.2",
        "x-build-id": "uA8Vs8sTb8pIBYm6B"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/herus13~linkedin-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-herus13-linkedin-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/herus13~linkedin-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-herus13-linkedin-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/herus13~linkedin-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-herus13-linkedin-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "profile_urls"
                ],
                "properties": {
                    "profile_urls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "List of LinkedIn profile URLs to scrape (e.g. https://www.linkedin.com/in/username)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cookie": {
                        "title": "LinkedIn Cookie (li_at) — REQUIRED",
                        "type": "string",
                        "description": "Your LinkedIn <code>li_at</code> session cookie. <strong>Required</strong> — LinkedIn now serves an authwall to anonymous requests from cloud infrastructure (Apify residential included), so a cookie is the only reliable way to access profile data. Find it in your browser: DevTools → <strong>Application</strong> → <strong>Cookies</strong> → <code>linkedin.com</code> → <code>li_at</code> → copy the value. Set <code>cookie_persist_key</code> below to avoid pasting it every run."
                    },
                    "cookie_persist_key": {
                        "title": "Persist cookie under this key (optional)",
                        "type": "string",
                        "description": "Optional. When set, the actor reads/writes the <code>li_at</code> cookie from your <strong>own</strong> Apify Key-Value Store (named <code>linkedin-profile-scraper-cookies</code>, scoped to your account). On first run, paste the <code>cookie</code> field too — it's saved under this key for future runs. Subsequent runs can omit <code>cookie</code> and just set this key to reuse the saved value. Use different keys for different LinkedIn accounts (e.g. <code>alice</code>, <code>bob</code>). The cookie never leaves your Apify account."
                    },
                    "scrape_contact_info": {
                        "title": "Scrape contact info (email, phone, websites, twitter, IM)",
                        "type": "boolean",
                        "description": "When enabled <em>and</em> a cookie is supplied (either inline or via persist key), fetches the profileContactInfo endpoint per profile (1 extra LinkedIn request each). Returns email, phone, websites, twitter handles, IM contacts, birthday, address. Ignored when no cookie is available.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy Configuration — country MUST match your cookie's country",
                        "type": "object",
                        "description": "<strong>The <code>country</code> field is mandatory and must match the country where you normally sign into LinkedIn (the country your cookie was generated in).</strong> Examples: <code>US</code> if you sign in from the United States, <code>GB</code> from the United Kingdom, <code>VN</code> from Vietnam, <code>DE</code> from Germany, <code>JP</code> from Japan. <br><br>Without a matching country, LinkedIn flags the request as a session hijack and deauthorizes the cookie within 1-2 requests — every profile returns HTTP 401. <br><br>Datacenter proxy will not work — LinkedIn blocks the entire DC IP range. Always use <code>RESIDENTIAL</code>."
                    },
                    "max_concurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum concurrent requests",
                        "default": 5
                    },
                    "max_requests_per_minute": {
                        "title": "Max Requests Per Minute",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Rate limit for requests",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
