# LinkedIn People Profile Activity  Cookie-less 🍪 ✅ (`datamagnet/linkedin-people-profile-activity`) Actor

Fetch recent LinkedIn activity for a profile in a clean, easy-to-read format. Choose posts, reactions, or comments and get more results automatically until your limit is reached.

- **URL**: https://apify.com/datamagnet/linkedin-people-profile-activity.md
- **Developed by:** [Datamagnet](https://apify.com/datamagnet) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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/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 Activity Scraper

LinkedIn Activity Scraper helps you quickly collect a person’s recent LinkedIn activity in a clean, easy-to-read format. It is ideal for recruiters, sales teams, marketers, analysts, and anyone who wants to review LinkedIn posts, reactions, or comments without manually scrolling through a profile. Enter a LinkedIn username, choose the activity type you want, and get a structured list of recent activity items with useful details like text, date, URL, and engagement information when available. The actor automatically keeps loading more results until it reaches your requested limit, making it a simple LinkedIn data collection tool for research and monitoring.

### Key Features

- Extract recent LinkedIn activity for a specific person in a clear, organized list.
- Collect posts, reactions, or comments based on the activity type you choose.
- Load more results automatically until your maximum number of items is reached.
- Show progress while running so you can see that the actor is working.
- Return useful activity details such as text, date, link, and engagement information when available.
- Clean and standardize the output so it is easier to review, compare, and export.
- Save time by replacing manual profile checking with automated LinkedIn activity collection.

### Use Cases

#### Recruiter Screening
Recruiters can review a candidate’s recent LinkedIn posts and comments to better understand how they communicate, what topics they care about, and how active they are in their professional network. The returned activity text, date, and URL help recruiters quickly scan for relevant updates without opening every profile manually.

#### Sales Prospect Research
Sales teams can use the actor to check a prospect’s recent reactions, posts, and comments before outreach. Seeing what someone has shared or engaged with can help a rep personalize a message, reference a relevant topic, and start a more informed conversation.

#### Brand and Thought Leadership Monitoring
Marketing teams and personal branding professionals can track how a person is showing up on LinkedIn through posts and comments. The activity list makes it easier to spot recurring themes, content style, and engagement patterns that support content planning or competitive analysis.

#### Partnership and Influencer Vetting
Partnership managers can review a creator, advisor, or industry expert’s recent LinkedIn activity before starting a collaboration. The actor’s output helps them assess whether the person is active, what they talk about, and whether their public presence aligns with the brand’s goals.

#### Competitive Intelligence
Analysts can monitor the public activity of executives, founders, or industry leaders to understand what they are posting and engaging with. The combination of activity type, content summary, and timestamps helps teams identify trends, announcements, and shifts in messaging.

#### Networking and Relationship Management
Professionals who manage a large network can use the actor to stay informed about important contacts. Recent activity details make it easier to follow up at the right time, mention a recent post, or respond to a comment in a more personal way.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| LinkedIn username | string | Yes | The LinkedIn profile name or profile link segment for the person whose activity you want to review. | satyanadella |
| Activity type | enum | Yes | Choose whether you want recent reactions, posts, or comments. | posts |
| Max results | integer | No | Set the total number of activity items you want returned. If needed, the actor will keep loading more until it reaches this limit. | 10 |

### Output

| Field | Type | Description |
|---|---|---|
| Activity type | string | Shows whether the item came from posts, reactions, or comments so you can sort the results easily. |
| Username | string | The LinkedIn profile name you searched for, making it easy to identify whose activity is included. |
| Activity text or content summary | string | The main text or a short summary of the activity, which helps you understand what the person shared or engaged with. |
| Activity date/time when available | string | The date or time of the activity, useful for tracking recency and spotting patterns over time. |
| Activity URL when available | string | A direct link to the activity item when available, so you can open the original post or comment quickly. |
| Any available engagement or metadata fields in a cleaned format | object | Extra useful details such as counts, labels, or other context that help you evaluate the activity at a glance. |
| Final count of returned items | integer | The total number of activity items returned after the actor finishes collecting results. |

### Sample Output

```json
{
  "activity_type": "posts",
  "username": "satyanadella",
  "activity_text_or_content_summary": "Excited to share updates on AI innovation and how it is shaping the future of work.",
  "activity_date_time_when_available": "2026-06-18T14:22:00Z",
  "activity_url_when_available": "https://www.linkedin.com/posts/example-activity",
  "engagement_or_metadata": {
    "likes": 1240,
    "comments": 86,
    "shares": 41,
    "visibility": "public"
  },
  "final_count_of_returned_items": 1
}
````

### How It Works

1. You enter the LinkedIn username or profile URL segment for the person you want to check.
2. You choose the type of activity you want to collect: reactions, posts, or comments.
3. You set the maximum number of results if you want more or fewer items.
4. The actor gathers the recent activity and keeps loading more until it reaches your limit.
5. You receive a clean list of results with helpful details ready for review or export.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, fill in the LinkedIn username, choose the activity type, and set the maximum results if needed. Then click **Run** and let the actor collect the data for you. When it finishes, you can review and download the results in **JSON, CSV, or Excel** format.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users who want a simple way to collect LinkedIn activity. You only need to enter a username, choose the activity type, and run it.

#### How fast does it run?

Speed depends on how many results you request and how much activity is available. Smaller requests usually finish quickly, while larger requests may take a bit longer because the actor keeps loading more items until it reaches your limit.

#### What format is the output?

The results are available in formats that are easy to review and share, including JSON, CSV, and Excel. This makes it simple to use the data in spreadsheets, reports, or internal workflows.

#### Is this legal to use?

You should always use the actor in a way that respects applicable laws, platform rules, and privacy expectations. It is best suited for lawful research, analysis, and business workflows involving publicly available information.

#### Can I schedule it to run automatically?

Yes. You can set it up to run on a schedule so you can keep track of a profile’s recent activity over time. This is useful for ongoing monitoring, reporting, and regular research updates.

# Actor input Schema

## `username` (type: `string`):

The LinkedIn profile username or profile URL to fetch activity for.

## `max_results` (type: `integer`):

The maximum number of activity items to return.

## `activity_type` (type: `string`):

Choose which kind of recent activity to fetch.

## Actor input object example

```json
{
  "username": "satyanadella",
  "max_results": 10,
  "activity_type": "posts"
}
```

# 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 = {
    "username": "satyanadella",
    "activity_type": "posts"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/linkedin-people-profile-activity").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 = {
    "username": "satyanadella",
    "activity_type": "posts",
}

# Run the Actor and wait for it to finish
run = client.actor("datamagnet/linkedin-people-profile-activity").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 '{
  "username": "satyanadella",
  "activity_type": "posts"
}' |
apify call datamagnet/linkedin-people-profile-activity --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn People Profile Activity  Cookie-less 🍪 ✅",
        "description": "Fetch recent LinkedIn activity for a profile in a clean, easy-to-read format. Choose posts, reactions, or comments and get more results automatically until your limit is reached.",
        "version": "0.0",
        "x-build-id": "hmreenqagT7UjBxgZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~linkedin-people-profile-activity/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-linkedin-people-profile-activity",
                "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/datamagnet~linkedin-people-profile-activity/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-linkedin-people-profile-activity",
                "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/datamagnet~linkedin-people-profile-activity/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-linkedin-people-profile-activity",
                "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": [
                    "username",
                    "activity_type"
                ],
                "properties": {
                    "username": {
                        "title": "LinkedIn profile username",
                        "type": "string",
                        "description": "The LinkedIn profile username or profile URL to fetch activity for."
                    },
                    "max_results": {
                        "title": "Maximum results",
                        "type": "integer",
                        "description": "The maximum number of activity items to return."
                    },
                    "activity_type": {
                        "title": "Activity type",
                        "enum": [
                            "reaction",
                            "posts",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Choose which kind of recent activity to fetch."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
