# LinkedIn Profile Scraper API - Real-Time Data (`virap/real-time-linkedin-profile-scraper-api`) Actor

Scrape LinkedIn profiles from URLs: names, job titles, companies, experience, education, skills, location, followers and connections. Get structured JSON for CRM enrichment, recruiting and lead generation. Run in Apify Console or use the real-time API. Pay per successful profile.

- **URL**: https://apify.com/virap/real-time-linkedin-profile-scraper-api.md
- **Developed by:** [VirAP](https://apify.com/virap) (community)
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.09 / 1,000 successful profiles

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 does LinkedIn Profile Scraper API do?

**LinkedIn Profile Scraper API** extracts structured professional profile data from a [LinkedIn](https://www.linkedin.com/) profile URL. Get names, headlines, job titles, companies, work experience, education, skills, location, followers and connections for **CRM enrichment, recruiting research and lead enrichment**.

Try one profile in Apify Console, download the result as JSON, CSV or Excel, or connect the Actor to your application through the API. Standard runs process one profile URL and finish; the standby server supports on-demand HTTP requests.

**Try a ready-made workflow:** [Enrich a LinkedIn profile for CRM](https://apify.com/virap/real-time-linkedin-profile-scraper-api/examples/enrich-a-linkedin-profile-for-crm). Copy the example, replace its sample URL, and export the profile fields you need.

### Why use this LinkedIn profile scraper?

- **Enrich CRM contacts:** turn an existing LinkedIn profile URL into professional and company information.
- **Research candidates:** inspect available roles, work history, education and skills in a consistent JSON structure.
- **Build sales workflows:** combine job titles, company links and locations with your own lead data.
- **Automate data collection:** use Apify API access, saved tasks, schedules, integrations and run monitoring.

You provide a profile URL. This Actor does not search LinkedIn for people by name, job title or company, and it does not promise email addresses or phone numbers.

### How to scrape a LinkedIn profile

1. Open the Actor's **Input** tab in Apify Console.
2. Paste one personal LinkedIn profile URL in the `https://www.linkedin.com/in/...` format. You can use the prefilled example for your first test.
3. Select **Start** and wait for the run to finish.
4. Open **Output** to inspect the profile. Use **Export** to download JSON, CSV or Excel.

No LinkedIn cookie or LinkedIn password is requested in the input form. For API integrations, authenticate to Apify with your own Apify token.

### Input

The **Input** tab describes the current input schema. Standard runs accept one field:

| Field | Required | Description |
|---|---|---|
| `profile_url` | Yes | Absolute LinkedIn personal profile URL containing `/in/`. Company pages and search URLs are not supported inputs. |

```json
{
  "profile_url": "https://www.linkedin.com/in/xavier-hen"
}
```

Each standard run processes **one profile URL**. To enrich multiple contacts, run the Actor once per URL or send individual requests to its standby API. An array of URLs is not an accepted input.

### Output: structured LinkedIn profile data

A successful standard run writes one profile object to the default dataset. The synchronous dataset API returns an array containing that object. You can download the dataset in JSON, HTML, CSV or Excel; JSON preserves nested experience, education and skill data.

The shortened example below uses illustrative values. Its field names and nesting match the Actor's returned profile structure:

```json
{
  "linkedin_profile_handle": "example",
  "first_name": "Alex",
  "last_name": "Example",
  "full_name": "Alex Example",
  "headline": "Product and engineering leader",
  "linkedin_profile_url": "https://www.linkedin.com/in/example",
  "profile_country": "FR",
  "location": "France",
  "job_title": "CTO",
  "company_name": "Example Company",
  "linkedin_company_url": "https://www.linkedin.com/company/123456",
  "number_connections": 500,
  "number_followers": 1141,
  "open_to_work": false,
  "languages": ["English", "French"],
  "skills": [{"name": "SaaS Architecture"}],
  "experiences": [{
    "title": "CTO",
    "company_name": "Example Company",
    "date": "Apr 2022 - Present",
    "job_contract_type": "Self-employed"
  }],
  "education": [{
    "school_name": "Example University",
    "degree_name": "Master's degree",
    "field_of_study": "Computer Science",
    "date": "2010 - 2015"
  }],
  "extracted_at": "2026-10-17T13:57:20.266Z"
}
```

#### Main output fields

| Data | Returned fields |
|---|---|
| Identity and profile | `full_name`, `first_name`, `last_name`, `headline`, `summary`, `linkedin_profile_handle`, `linkedin_profile_url`, `profile_image_url` |
| Current role and company | `job_title`, `company_name`, `linkedin_company_url`, `linkedin_company_id` |
| Work history | `experiences[]`, including available titles, companies, dates, locations, contract types and work arrangements |
| Education | `education[]`, `school_name`, `linkedin_school_url` |
| Skills and languages | `skills[]`, `languages[]` |
| Location | `location`, `profile_country` |
| Audience and status | `number_followers`, `number_connections`, `open_to_work` |
| Previous role | `past_company_name`, `past_job_title`, `past_linkedin_company_url`, `past_linkedin_company_id` |
| Additional identifiers | `linkedin_profile_id`, `sales_navigator_profile_id`, `past_sales_navigator_company_id` |
| Other history and metadata | `volunteer_experiences[]`, `extracted_at` |

Fields depend on profile availability. Some values can be missing, empty or null. Multiple current positions may appear in `experiences`; the top-level company field can summarize more than one position. The extraction timestamp records when the response was produced, rather than guaranteeing every source field changed at that moment.

### Pricing: how much does LinkedIn profile enrichment cost?

The Actor uses **Pay Per Event** pricing for successful profile enrichment.

| Apify discount tier | Price per 1,000 successful profiles |
|---|---:|
| No discount | $1.49 |
| Bronze | $1.39 |
| Silver | $1.29 |
| Gold | $1.09 |

For example, 100 successful profiles cost $0.149 at the listed no-discount event rate. Invalid URLs, profiles not found, rate limits, timeouts and server errors are not billed as successful profile events. Check the live **Pricing** tab for current rates, plan discounts and applicable charges. Use a maximum cost per run when testing.

**Standard runs:** the listed profile-event rate includes Apify platform usage under this Actor's current pricing settings. **Standby API:** Apify charges platform usage in addition to profile-event charges, including the resources used while the server is active. A failed enrichment has no successful-profile event charge, but Standby platform usage can still apply. Discount eligibility is determined by Apify; it is not a promise tied to a particular plan name.

### LinkedIn profile scraping API

#### Standard API: run once and return the dataset

Use the Apify synchronous endpoint to submit one URL and receive the profile dataset. Store the token in the `APIFY_TOKEN` environment variable in your server-side environment.

```bash
curl -X POST \
  'https://api.apify.com/v2/actors/virap~real-time-linkedin-profile-scraper-api/run-sync-get-dataset-items?timeout=120&maxTotalChargeUsd=0.02' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"profile_url":"https://www.linkedin.com/in/xavier-hen"}'
```

The response is a JSON array of dataset items. For longer workflows, use the Actor's **API** tab to start a run asynchronously and retrieve its dataset after completion.

#### Python example

```python
import os
import requests

response = requests.post(
    "https://api.apify.com/v2/actors/virap~real-time-linkedin-profile-scraper-api/run-sync-get-dataset-items",
    params={"timeout": 120, "maxTotalChargeUsd": 0.02},
    headers={"Authorization": f"Bearer {os.environ['APIFY_TOKEN']}"},
    json={"profile_url": "https://www.linkedin.com/in/xavier-hen"},
    timeout=130,
)
response.raise_for_status()
profiles = response.json()
print(profiles)
```

#### Standby API: on-demand profile enrichment

For repeated HTTP calls, open the **Server** tab, use the Actor's standby URL, and send:

```text
POST https://virap--real-time-linkedin-profile-scraper-api.apify.actor/v1/people/enrich
Authorization: Bearer YOUR_APIFY_TOKEN
Content-Type: application/json
```

```json
{"profile_url":"https://www.linkedin.com/in/xavier-hen"}
```

The stable Standby address above is shown in this Actor's Server tab. Authenticate with an Apify token in the Authorization header. Use `GET /health` for the service health endpoint. A healthy server response confirms service availability; it does not confirm that a particular profile can be enriched.

#### Connect to n8n or Make

Use an HTTP Request module with the standard POST endpoint above. Set Authorization to `Bearer YOUR_APIFY_TOKEN`, choose JSON body, and map your contact's LinkedIn URL to `profile_url`. The result is an array containing the enriched profile; map its available fields to your CRM or spreadsheet. Start with one contact and a small spending limit before enabling a larger workflow.

### Tips for reliable enrichment

- Use canonical personal profile URLs rather than search links or company pages.
- Start with one profile and inspect its output before integrating a larger workflow.
- Configure timeouts and maximum run costs. Increase concurrency gradually and handle rate limits.
- Retry temporary `429` and `5xx` responses with a delay and backoff. Correct invalid input before retrying.
- Keep nested fields as JSON when you need full education and work-history records.
- Keep Apify tokens in trusted server-side environments and out of public code, URLs and browser clients.

Performance varies with cold starts, profile availability, concurrency and upstream response times. No fixed latency or throughput is guaranteed.

### FAQ and support

#### Does this Actor find people or return email addresses?

It enriches a LinkedIn profile URL that you already have. It is not a LinkedIn people-search tool or an email/phone finder.

#### Can I use it without writing code?

Yes. Paste a URL in Apify Console, start the Actor, then export its dataset. Saved tasks, schedules and integrations can help repeat the workflow.

#### Why are some fields missing?

Profiles expose different information. Unavailable fields may be absent, null or empty. Field completeness and profile availability are not guaranteed.

#### What do API errors mean?

The Apify gateway requires a valid token (`401`/`403` on authentication or access errors). A `402` response means the configured spending limit cannot cover the next successful profile. The standby API uses `400` for invalid profile URLs, `404` for profiles not found, `422` for invalid requests, `429` for rate limiting, `502` for upstream errors and `504` for timeouts. Apify platform endpoints have their own response codes; inspect the run log when diagnosing a standard run.

#### Where can I report a problem?

Open the Actor's [Issues tab](https://apify.com/virap/real-time-linkedin-profile-scraper-api/issues). Include the run ID, expected behavior and relevant error message. Never include API tokens or other credentials.

This independent tool is not affiliated with, endorsed by or sponsored by LinkedIn Corporation or Microsoft Corporation. Use the Actor and returned data in accordance with applicable laws, privacy requirements and relevant platform terms.

# Actor input Schema

## `profile_url` (type: `string`):

One absolute personal LinkedIn profile URL in the https://www.linkedin.com/in/... format. Use the prefilled URL to try the Actor. Company pages, search links and arrays of URLs are not supported.

## Actor input object example

```json
{
  "profile_url": "https://www.linkedin.com/in/example"
}
```

# Actor output Schema

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

Successfully enriched LinkedIn profile data from standard Actor runs.

# 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_url": "https://www.linkedin.com/in/xavier-hen"
};

// Run the Actor and wait for it to finish
const run = await client.actor("virap/real-time-linkedin-profile-scraper-api").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_url": "https://www.linkedin.com/in/xavier-hen" }

# Run the Actor and wait for it to finish
run = client.actor("virap/real-time-linkedin-profile-scraper-api").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 '{
  "profile_url": "https://www.linkedin.com/in/xavier-hen"
}' |
apify call virap/real-time-linkedin-profile-scraper-api --silent --output-dataset

```

## MCP server setup

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

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/SgkHsEfHzlPxLQScQ/builds/sdAwMHfB4EGsiXUpy/openapi.json