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

Look up one public LinkedIn member page and return a source-dependent profile snapshot with identity, roles, experience, education, articles, activity, and displayed counts.

- **URL**: https://apify.com/truefetch/linkedin-profile-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Business, Social media, Automation
- **Stats:** 29 total users, 5 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.10 / result

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 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

**Independent LinkedIn data extraction Actor.** LinkedIn Person Profile is not affiliated with, endorsed by, or operated by LinkedIn or Microsoft. It reads information exposed on a public member page; source access, visibility, fields, and values can change without notice.

LinkedIn Person Profile converts one `linkedin.com/in/...` URL into a source-dependent person snapshot. A populated Dataset row has 19 top-level keys covering provenance, identity, headline, About text, displayed location, image URL, follower and connection counts, source-inferred current companies and titles, experience, education, article samples, and activity samples.

- A verified Andrew Ng run returned one row with all 19 top-level keys.
- That row contained 8 experience entries, 3 education entries, 2 article records, and 10 activity records.
- A Bill Gates run on the same cloud Build ended normally with zero rows and no Result event.
- Every populated row carries its source URL, canonical member URL, timestamp, status, page type, and Actor provenance.

This Actor is a public-page snapshot extractor, not an identity, employment, education, contact, or background-verification service. Source-selected content can be stale, incomplete, approximate, or unavailable. Do not use it as the sole basis for hiring, eligibility, credit, housing, insurance, or another consequential decision.

[Run one person profile](https://console.apify.com/actors/xbKLwhle3H8lmpXTG/input) · [Connect through the Apify API](https://docs.apify.com/api/v2)

### What does LinkedIn Person Profile do?

The Actor accepts one HTTPS LinkedIn member-page URL, requests the public page through its normal network path, extracts available Person data and visible sections, normalizes counts and URLs, and writes one Dataset row when a name can be parsed. It does not perform a member search or process a batch.

A populated row always contains the same 19 top-level keys. Provenance fields identify this observation; profile fields contain public source values; and five array fields carry current-company labels, job-title labels, experience entries, education entries, articles, or activity. Extracted scalars can be `null`, while arrays can be empty.

The Actor does not sign into LinkedIn, accept cookies or credentials, access Sales Navigator or Recruiter data, reveal private contact information, confirm identity, or verify profile claims. It also does not guarantee that a public-looking URL will be parsable on every run. A successful process can end with zero Dataset items when the source page is unavailable or no name is detected.

### How do I run LinkedIn Person Profile?

Open the Actor input, provide one standard LinkedIn `/in/` URL, and start the run. Company, job, search, and off-domain URLs are outside the schema.

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

Wait for a terminal status and inspect the default Dataset. Do not interpret `SUCCEEDED` alone as proof that a profile row exists. The verified Andrew Ng baseline wrote one row and charged Actor Start `1` plus Result `1`; the Bill Gates baseline finished successfully with zero rows and Start/Result `1/0`.

For a controlled rollout, retain the run ID, Dataset ID, build number, input URL, status message, item count, charged-event counts, and timestamp. Check the actual key set and array sizes before connecting the output to a CRM, research store, or AI system. If a run is empty, verify the URL and retry later rather than launching many immediate duplicates.

### What data does LinkedIn Person Profile return?

The populated-row envelope has 19 top-level keys:

| Group | Fields | Interpretation |
| --- | --- | --- |
| Provenance | `source_url`, `processor`, `processed_at`, `status`, `type` | Trace data for this Actor observation, not external verification. |
| Identity | `linkedin_url`, `name`, `headline`, `about`, `profile_image_url` | Source text and media; image links can expire. |
| Place and counts | `location`, `follower_count`, `connection_count` | Displayed snapshots; location is not a verified residence and counts may change or be capped. |
| Current-role signals | `current_companies`, `job_titles` | Source-structured labels; empty arrays do not prove unemployment. |
| History | `experiences`, `education` | Parsed visible entries, not complete or independently verified histories. |
| Content samples | `articles`, `activity` | Source-visible samples, not complete publication or activity archives. |

This shortened example uses values from a verified Andrew Ng run. It does not promise that future counts or arrays will match.

```json
{
  "source_url": "https://www.linkedin.com/in/andrewyng/",
  "processor": "https://apify.com/truefetch/linkedin-person-profile?fpr=aiagentapi",
  "processed_at": "2026-07-23T22:21:06+00:00",
  "status": "success",
  "type": "person",
  "linkedin_url": "https://www.linkedin.com/in/andrewyng/",
  "name": "Andrew Ng",
  "headline": "DeepLearning.AI, AI Fund and AI Aspire",
  "location": "Palo Alto, California, United States",
  "follower_count": 2570458,
  "connection_count": 500,
  "current_companies": ["DeepLearning.AI", "AI Fund", "LandingAI"],
  "job_titles": ["Founder", "Managing General Partner"],
  "experiences": [{"title": "Founder", "company": "DeepLearning.AI"}],
  "education": [{"school": "Massachusetts Institute of Technology"}],
  "articles": [],
  "activity": []
}
```

Experience and education objects can include source URLs, logos, raw date ranges, parsed years, degree, and duration. Article and activity records can include source text, timestamps, media links, URLs, reaction counts, and comment counts. Individual nested values can be missing, and third-party URLs can redirect or expire.

### What inputs can I configure?

| Parameter | Type | Required | Format | Behavior |
| --- | --- | --- | --- | --- |
| `linkedin_url` | string | Yes | `https://www.linkedin.com/in/{slug}/` | One public LinkedIn member page. Unsupported paths and malformed forms fail schema validation. |

There is no URL list, result-count setting, member-name query, employer filter, title filter, date range, geographic filter, cookie field, credential field, or contact-enrichment switch. Use a separate run per member URL.

The runtime trims and lowercases input and checks for a LinkedIn `/in/` path. The public schema intentionally requires a complete HTTPS URL on the standard host, avoiding scheme-less values that cannot be canonicalized reliably. A URL identifies the requested page; it does not prove identity or establish a lawful processing purpose.

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

The only supported source is a public LinkedIn member path on `www.linkedin.com`. The input has no country or language selector. Profiles can refer to people in different regions, but accessibility, localized text, available sections, and source formatting vary by page and request context.

Coverage is not a claim of global completeness. Private, restricted, removed, minimal, or temporarily unavailable profiles can yield zero rows. Displayed locations may be broad self-described regions. Counts and public sections can change between observations. The Actor does not access company pages, Sales Navigator, Recruiter, private messages, account connections, or non-public profile sections.

### Why use LinkedIn Person Profile?

The Actor provides a stable machine-readable envelope around a changing public page. Instead of coupling a pipeline directly to HTML, consumers receive 19 named fields, a timestamp, canonical member URL, and Actor provenance. A fixed top-level envelope simplifies nullable-field and empty-array handling.

It also makes source failure explicit. One run can return a structured row while another succeeds with no row. Dataset count and Result event count expose that difference, helping integrations avoid mistaking process completion for data availability.

The narrow one-URL contract supports traceability. Each run can remain linked to its requested source, outcome, event counts, and review decision. That is more defensible than combining unrelated profiles without per-subject evidence.

### Who is LinkedIn Person Profile for?

Recruiting teams can collect permitted public snapshots for already identified candidates, with human review and separate verification. Parsed work and education sections are research leads, not credential checks.

Account and market researchers can prepare source-linked briefs using public headline, current-company, title, and content signals. They must not treat a source-selected person as a confirmed decision-maker or assume permission for outreach.

Developers can integrate the fixed envelope into ETL pipelines, AI tools, and review queues. Data-quality teams can compare key presence, null rates, array sizes, and counts across observation times. Researchers should treat articles and activity as samples and use consistent intervals.

The Actor is not suitable as a sole source for identity resolution, contact discovery, regulated eligibility decisions, exact network analysis, complete career histories, or unattended high-impact automation.

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

The stable Actor ID is `xbKLwhle3H8lmpXTG`, and the full name is `truefetch/linkedin-person-profile`. Through the Apify API, start a run using the single-field input, poll terminal status, and read items from `defaultDatasetId`. Keep tokens in server-side secret storage and out of URLs, prompts, and logs.

MCP clients should fetch current Actor details before calling it. A minimal request is:

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

If the wait window expires while the run remains active, poll the same run instead of creating a duplicate. Read the Dataset independently and verify item count. An MCP account policy can allow Actor metadata and Dataset reads while refusing public Actor execution; that access-policy response is distinct from an Actor failure.

Consumers should represent zero rows separately from a later profile change. Do not silently reuse an old snapshot when the new source request produces no item.

### How much does LinkedIn Person Profile cost?

The Actor uses pay-per-event pricing. The Apify Console and the charged events stored with a run are authoritative.

| Event | Trigger | Free | Bronze | Silver | Gold | Platinum | Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor Usage | Runtime, proxy, and storage consumption | `$0.00001` per usage unit | same | same | same | same | same |
| Actor Start | Actor starts; platform memory rules affect counted starts | `$0.01` | same | same | same | same | same |
| Result | One person row written to the default Dataset | `$0.10000` | `$0.09667` | `$0.09333` | `$0.09000` | `$0.09000` | `$0.09000` |

At the Free-tier Result rate, one populated run contributes `$0.10000` for Result plus Actor Start and metered Actor Usage. A zero-row run has no Result event but can still incur Start and Usage. The two baseline branches produced Start/Result `1/1` and `1/0`, respectively.

Estimate spend from attempted runs, not only expected rows. If 100 attempts all produce a row, Result charges at the Free tier contribute `$10.00` before Start and Usage. A maximum-total-charge cap is a billing control, not a source-availability guarantee.

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

Manual review is appropriate for one consequential profile because a person can inspect context and notice ambiguity. It is difficult to repeat consistently and preserve as structured evidence. This Actor is useful when you need a fixed JSON envelope, timestamps, and run IDs.

Generic browser automation offers more control over navigation or screenshots but adds maintenance when source markup changes. Approved LinkedIn products have different authentication, permissions, features, and terms. A licensed people-data provider may add verification or contact fields from other sources. LinkedIn Person Profile stays narrower: one public member URL and source-dependent visible data.

Choose the source that matches your legal basis and evidence requirement. Use this Actor for observation and workflow support; use direct confirmation or qualified providers when identity, employment, education, or contact accuracy matters.

### What are the limits and troubleshooting steps?

A run can succeed with zero Dataset items. First confirm the URL uses HTTPS and the `/in/` path. Then inspect status, status message, Dataset count, and whether the page is publicly reachable. Retry later if appropriate; avoid bursts of duplicate runs.

Null fields and empty arrays are valid. A missing experience, school, article, or activity record can reflect source visibility, page variants, or parsing conditions rather than a real-world absence. Counts can change across close runs and connection values can be capped.

For integration problems, record the run ID, build number, Dataset ID, item count, key set, event counts, and redacted input. Never send tokens, credentials, cookies, private Datasets, or unrelated personal information to support.

### Frequently asked questions

#### Does every successful run return a row?

No. Successful process completion can coexist with zero Dataset items. Check both status and item count.

#### Does a populated row always have 19 keys?

Yes, under the verified execution path. Extracted scalar values can be `null`, and array values can be empty.

#### Are experience and education verified?

No. They are parsed public source entries and can be incomplete, stale, or incorrect.

#### Are follower and connection counts exact?

They are displayed snapshots. Source formatting can cap or approximate values, and counts can change.

#### Does this return emails or phone numbers?

No supported output field represents an email or phone number, and the Actor does not accept account credentials.

#### Can I run a batch?

The Actor accepts one member URL per run. Start separate traceable runs for separate URLs.

### Related TrueFetch Actors

- [LinkedIn Company Profile](https://apify.com/truefetch/linkedin-company-profile?fpr=aiagentapi) handles one public company page under a separate sparse schema.
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing?fpr=aiagentapi) focuses on vacancy discovery rather than member-profile snapshots.
- [Job Search](https://apify.com/truefetch/job-search?fpr=aiagentapi) provides a broader job-search workflow with independent inputs, fields, and pricing.

Review each Actor's current schema, pricing, source boundary, and legal fit before combining outputs.

### Support and last updated

For a reproducible issue, provide the run ID, redacted or already-public member URL, build number, status message, Dataset item count, top-level key set, and charged-event counts. State whether the problem concerns validation, source availability, a null value, nested data, count parsing, billing, or integration.

Use [TrueFetch support on Telegram](https://t.me/AiAgentApi) for Actor-specific help and the [Apify community](https://discord.com/invite/jyEM2PRvMU) for platform questions. Do not share secrets, credentials, cookies, private Datasets, or unnecessary personal information.

Last updated: July 23, 2026.

# Actor input Schema

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

One public LinkedIn member-page URL in the supported /in/ path format

## Actor input object example

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

# Actor output Schema

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

The looked-up person row. Extracted values can be null or empty, and a completed run can return zero rows.

# 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/andrewyng/"
};

// 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/andrewyng/" }

# 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("💾 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 '{
  "linkedin_url": "https://www.linkedin.com/in/andrewyng/"
}' |
apify call truefetch/linkedin-profile-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xbKLwhle3H8lmpXTG/builds/wSywplhP2A698CsYz/openapi.json