# LinkedIn Profile API (`truefetch/linkedin-profile-api`) Actor

LinkedIn profile scraper for one public member URL. Export a sparse 24-field person snapshot with identity, roles, experience, education, articles, activity, counts, and provenance.

- **URL**: https://apify.com/truefetch/linkedin-profile-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Lead generation, Social media, Integrations
- **Features:** Limited permissions
- **Stats:** 40 total users, 1 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.05625 / result

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Profile API

**LinkedIn Profile API is a linkedin profile scraper that converts one public member URL into a sparse 24-field JSON snapshot with career, education, content, count, and provenance data.**

- **One run processes exactly one public LinkedIn `/in/` URL and returns at most one identity-matching person row.**
- **The requested slug, final response URL, and page canonical URL must agree before a result is accepted.**
- **The Dataset exposes 24 possible top-level fields without inventing missing source values.**
- **A failed image can be omitted while the valid text profile remains usable.**

[**Run a one-profile test**](https://apify.com/truefetch/linkedin-profile-api) · [**View the API**](https://apify.com/truefetch/linkedin-profile-api/api)

The smallest useful FREE-tier test uses the prefilled Bill Gates URL and costs $0.01 for Actor Start plus $0.075 for one Profile Result, or $0.085 total when a row is saved.

### What does LinkedIn Profile API do?

LinkedIn Profile API turns one known public member-page URL into a traceable person snapshot for recruiting review, CRM enrichment, professional research, data-quality analysis, or a monitored panel. A row can contain identity, headline, About text, displayed location and country, profile image, follower and connection counts, job titles, affiliations, work experience, education, languages, awards, articles, recent activity, and processing metadata.

The Actor keeps source boundaries visible. `linkedin_url` identifies the canonical member page, `processed_at` records the observation time, and optional values appear only when the response contains them. It does not search by a person's name, sign in to LinkedIn, discover private contact details, verify employment or education, or convert one profile into a complete relationship graph.

Identity validation is part of the contract. LinkedIn can sometimes serve or redirect to a valid Person page that belongs to someone other than the requested slug. The Actor checks the requested path, final response URL, and HTML canonical link, rejecting a mismatch rather than returning the wrong person under the requested input.

### How do I run LinkedIn Profile API?

LinkedIn Profile API needs one public member URL.

1. Open the [Actor input page](https://console.apify.com/actors/xbKLwhle3H8lmpXTG/input).
2. Keep the prefilled Bill Gates URL or replace it with another public HTTPS LinkedIn URL under `/in/{slug}/`.
3. Start the run and wait for the terminal message.
4. Inspect the default Dataset independently of the process status; source unavailability can leave it empty.
5. Save the run ID, Dataset ID, canonical URL, item count, and `processed_at` value with downstream records.

```json
{
  "linkedin_url": "https://www.linkedin.com/in/williamhgates/"
}
```

Each person requires a separate run. This keeps the input, identity decision, Result event, Dataset item, and processing time independently traceable.

### What data does LinkedIn Profile API return?

LinkedIn Profile API returns one sparse object with up to 24 top-level fields and nested arrays for background and public content.

| Group | Possible fields | Interpretation |
| --- | --- | --- |
| Identity | `platform`, `type`, `linkedin_url`, `name` | Source and canonical member identity |
| Profile | `headline`, `about`, `location`, `country_code`, `profile_image_url` | Public summary, displayed place, and stored image |
| Counts and roles | `follower_count`, `connection_count`, `job_titles`, `affiliations` | Displayed counts and current-role context derived from the response |
| Background | `experiences`, `education`, `languages`, `skills`, `awards`, `publications` | Public career, education, language, skill, award, and publication sections |
| Content | `articles`, `activity` | Sampled public articles and recent activity cards |
| Processing | `status`, `processor`, `processed_at` | Result state, producing Actor, and observation time |

```json
{
  "platform": "LinkedIn Profile Lookup",
  "type": "person",
  "linkedin_url": "https://www.linkedin.com/in/williamhgates/",
  "name": "Bill Gates",
  "headline": "Co-chair, Bill & Melinda Gates Foundation",
  "location": "Seattle, Washington, United States",
  "country_code": "US",
  "follower_count": 37000000,
  "connection_count": 500,
  "job_titles": ["Co-chair"],
  "status": "success",
  "processor": "https://apify.com/truefetch/linkedin-profile-api",
  "processed_at": "2026-08-12T17:45:00-07:00"
}
```

The values above illustrate the shape, not a permanent claim about the member. Public pages and displayed counts change. Nested entries can omit their own optional keys, and the Actor removes an image field when the image cannot be downloaded and stored safely.

### What inputs can I configure?

LinkedIn Profile API exposes one required string and no cookies, credentials, proxy settings, or hidden request filters.

| Parameter | Type | Required | Format | Behavior |
| --- | --- | --- | --- | --- |
| `linkedin_url` | string | Yes | `https://www.linkedin.com/in/{slug}/` | Selects one public member page; accepted query or fragment noise is removed during normalization |

The runtime rejects HTTP, foreign hosts, credentialed URLs, company paths, extra member subpaths, empty slugs, and non-string values. It does not accept an array, person name, keyword, employer, location, language, date, email, phone number, or Sales Navigator URL. Submit only an identified public member URL that the intended workflow is permitted to process.

### What platforms and markets does LinkedIn Profile API cover?

LinkedIn Profile API covers public LinkedIn member URLs under `/in/`. LinkedIn controls which profiles are publicly reachable, which fields appear, how pages are localized, and whether an anonymous response is complete enough to parse. A member from another country can be requested when the public page is reachable, but field labels, text language, count presentation, and section density can vary.

There is no country, language, or market selector. `country_code` is retained only when the response provides enough source information for the formatter's supported mapping; absence does not prove that a person has no country. Likewise, a missing language or award section says only that it was not retained from that snapshot.

Private profiles, login-only views, search-result pages, company pages, school pages, and Sales Navigator URLs are outside the input contract. The Actor does not claim complete geographic coverage or equivalent visibility across members.

### Why use LinkedIn Profile API?

LinkedIn Profile API is useful when a workflow needs a stable sparse envelope around a changing public profile. A Dataset item is easier to validate, export, join, and monitor than copied page text because the canonical URL, named fields, status, producing Actor, and observation time travel together.

The identity check is equally important. Detecting generic Person markup is not enough when the source returns a different valid member. Requiring requested, final, and canonical slug agreement reduces the risk of attaching another person's public data to the requested record.

The omission policy keeps uncertainty visible. An absent headline, affiliation, image, education item, article, or activity card is not silently converted into a guessed fact. Downstream systems can test key presence, compare snapshots, and route sparse records for review.

### Who is LinkedIn Profile API for?

LinkedIn Profile API is for developers, recruiters, researchers, revenue operations teams, and data-quality analysts who already know the public profile URL they need to observe.

Recruiting teams can prepare a source-linked candidate dossier for human review. CRM teams can add public headline, location, job-title, affiliation, and activity signals to an existing record without treating them as verified contact data. Researchers can collect repeated snapshots for a defined panel, while quality teams can compare key presence, array sizes, counts, canonical identity, and timestamps.

It is not suitable as a sole source for identity verification, background checks, regulated eligibility decisions, automated employment decisions, private contact discovery, complete work history, or bulk prospect generation from names. Those uses need additional authoritative sources, permission analysis, human review, or a different product contract.

### How can I use LinkedIn Profile API through the API or MCP?

Call the Actor by stable ID `xbKLwhle3H8lmpXTG` or name form `truefetch/linkedin-profile-api`, then read `defaultDatasetId` after the run reaches a terminal state.

```bash
curl -X POST "https://api.apify.com/v2/acts/xbKLwhle3H8lmpXTG/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"linkedin_url":"https://www.linkedin.com/in/williamhgates/"}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("xbKLwhle3H8lmpXTG").call(run_input={
    "linkedin_url": "https://www.linkedin.com/in/williamhgates/",
})
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
```

```json
{
  "actor": "truefetch/linkedin-profile-api",
  "input": {"linkedin_url": "https://www.linkedin.com/in/williamhgates/"},
  "callOptions": {"memory": 128, "timeout": 300},
  "waitSecs": 60
}
```

If a client wait expires, poll the existing run ID instead of launching a duplicate. Keep Apify tokens in server-side secret storage and exclude them from browser code, logs, Dataset rows, and support messages.

### How much does LinkedIn Profile API cost?

LinkedIn Profile API uses pay-per-event pricing. Actor Start costs $0.01, and a saved Profile Result ranges from $0.075 to $0.05625 by plan.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor Start | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 |
| Profile Result | $0.07500 | $0.06750 | $0.06000 | $0.05625 | $0.05625 | $0.05625 |

Actor Start is one time per run. The Profile Result is one time and applies only when one row is pushed to the default Dataset. The smallest saved FREE-tier run is `$0.01 + $0.075 = $0.085`; a run that produces no Dataset row has no Result event. Check the live [pricing page](https://apify.com/truefetch/linkedin-profile-api/pricing) before setting a maximum-total-charge policy because prices can change.

### How does LinkedIn Profile API compare with alternatives?

LinkedIn Profile API trades breadth for a narrow, traceable one-person contract. Manual review is often better for one high-stakes profile when a person needs the current visual context, interactive navigation, and immediate judgment. It is harder to repeat consistently, export as sparse JSON, or connect to a scheduled Dataset workflow.

LinkedIn's own member page is the authoritative presentation surface and is preferable when a human needs the latest visible experience. A licensed professional-data provider may be preferable when the requirement is contracted coverage, verified identity resolution, historical records, contact information, or permitted bulk search from names and organizations.

Choose another workflow when the input must be a company, a keyword search, or hundreds of URLs in one run; when private or login-only data is required; or when a complete and independently verified career history is essential. This Actor observes one known public member URL.

### What are the limits and troubleshooting steps?

LinkedIn Profile API can return sparse data or no row when the public source is unavailable, changed, restricted, or missing a parsable identity.

- **No Dataset item:** verify HTTPS and the exact `/in/{slug}/` path, confirm the public page opens, inspect the terminal message, and retry later.
- **Identity mismatch:** LinkedIn returned another canonical member page; the Actor rejects it instead of attaching the wrong person to the input.
- **Missing field:** treat absence as “not observed in this snapshot,” compare another run, and do not substitute a factual zero.
- **Missing media:** keep the valid text profile; an image is removed when it cannot be downloaded and stored safely.
- **Changing counts:** preserve `processed_at` and confirm movement across repeated observations before interpreting it.
- **Expired client wait:** poll the existing run by ID rather than starting a duplicate.

For a reproducible issue, include the run ID, redacted input, terminal status, Dataset item count, expected field, and observed key set. Never include tokens, credentials, private Dataset content, or unrelated personal data.

### Frequently asked questions

#### Is this a linkedin profile scraper for public member pages?

Yes. It accepts one public member URL and returns the subset available in a sparse 24-field contract. It does not sign in or access private profiles.

#### Does every successful process return a Dataset row?

No. The public source can be unavailable, restricted, changed, or identity-mismatched. Inspect the terminal message and Dataset count separately.

#### Does every row contain all 24 fields?

No. Optional values can be absent or null according to the schema, so consumers should test key presence.

#### Are employment and education entries verified?

No. They are parsed observations from the public response, not independent identity, employment, degree, or background verification.

#### Are follower and connection counts exact?

They are displayed source values for that snapshot and can be capped, rounded, unavailable, or changed later.

#### Does the Actor find email addresses or phone numbers?

No. The input and output contracts do not include email discovery, phone discovery, credentials, or private account data.

#### Can I submit a URL list or person name?

No. The only supported input is one public LinkedIn member URL under `/in/`.

#### Can I schedule repeated profile snapshots?

Yes. Apify schedules can start repeated runs, but each run handles one URL and any apparent personal or career change should receive cautious human review.

### Related TrueFetch Actors

LinkedIn Profile API pairs with exactly three separate TrueFetch products when the workflow extends from one member to company or job research.

- **[LinkedIn Company API](https://apify.com/truefetch/linkedin-company-api)** — retrieve one public company snapshot under a separate company contract.
- **[LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing)** — focus on LinkedIn vacancy discovery rather than one person profile.
- **[Job Search](https://apify.com/truefetch/job-search)** — search jobs across a broader source set with independent inputs and pricing.

Review each Actor's current input, Dataset contract, source boundary, and pricing before combining records.

### Support

LinkedIn Profile API support covers valid member URLs, identity mismatches, sparse fields, pricing events, Dataset access, and integration behavior. Open an [Issue](https://apify.com/truefetch/linkedin-profile-api/issues) with reproducible details.

Include the run ID, redacted input, terminal message, Dataset item count, observed key set, and expected behavior. Do not send credentials, tokens, private Dataset content, or unrelated personal information.

[**Run a one-profile test**](https://apify.com/truefetch/linkedin-profile-api) · [**View the API**](https://apify.com/truefetch/linkedin-profile-api/api)

**Last Updated:** August 12, 2026

# Actor input Schema

## `linkedin_url` (type: `string`):

Public /in/ member URL for one sparse, identity-matched profile snapshot

## Actor input object example

```json
{
  "linkedin_url": "https://www.linkedin.com/in/williamhgates/"
}
```

# Actor output Schema

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

The 24-field person row with structured affiliations, education, languages, awards, public content, and KVS-backed images; unavailable source keys are omitted.

# 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 = {
    "linkedin_url": "https://www.linkedin.com/in/williamhgates/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/linkedin-profile-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 = { "linkedin_url": "https://www.linkedin.com/in/williamhgates/" }

# Run the Actor and wait for it to finish
run = client.actor("truefetch/linkedin-profile-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 '{
  "linkedin_url": "https://www.linkedin.com/in/williamhgates/"
}' |
apify call truefetch/linkedin-profile-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/linkedin-profile-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/xbKLwhle3H8lmpXTG/builds/csrnCTKJUNHgTdb9b/openapi.json