# LinkedIn Pulse Article Scraper · No Cookies · $2/1k ✅ (`linkedintel/linkedin-pulse-article-scraper-no-cookies`) Actor

The only LinkedIn Pulse article scraper on Apify Store. Full HTML content + engagement breakdown + author info per article. No cookies, no login. $2/1k pay-per-result.

- **URL**: https://apify.com/linkedintel/linkedin-pulse-article-scraper-no-cookies.md
- **Developed by:** [LinkedIntel](https://apify.com/linkedintel) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 record extracteds

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 Pulse Article Scraper — Full long-form articles, no cookies

Scrape **LinkedIn Pulse long-form articles** by author — full HTML content, engagement metrics, reaction breakdowns by type, and (optionally) all comments. Clean structured JSON output. **No LinkedIn login, no cookies, no browser session, no account ban risk.**

Built for **content marketing intelligence, thought-leadership tracking, competitive content analysis, archival research, and AI training data**.

---

### The only LinkedIn Pulse scraper on Apify Store

We searched the entire store: **zero competitors scrape LinkedIn Pulse articles**. Every major LinkedIn vendor (harvestapi, supreme_coder, bebity, get-leads, curious_coder, apidojo) focuses on profiles, companies, posts, and reactions — none of them handles long-form Pulse content.

That makes sense from their economics: short posts are easier and cheaper to scrape than full-page article HTML. But it leaves a gap: **how do you systematically track thought-leadership content from CEOs, analysts, VCs, and industry influencers**?

| | harvestapi | supreme_coder | bebity | get-leads | curious_coder | **This actor** |
|---|---|---|---|---|---|---|
| Pulse Articles | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
| Full HTML content | — | — | — | — | — | ✅ (3-50KB per article) |
| Engagement breakdown by reaction type | — | — | — | — | — | ✅ |
| Article comments included | — | — | — | — | — | ✅ (toggleable) |

### What you get — full pulse article per row

For each profile you input, the actor returns one `pulseArticle` record per article found (up to `maxArticlesPerProfile`).

#### `pulseArticle` record (24 fields)
- **Identity**: `articleUrn`, `permalink`, `activityUrn`, `threadUrn`
- **Content**: `title`, `contentHtml` (full HTML), `state` (PUBLISHED / draft)
- **Author**: `authorName`, `authorHeadline`, `authorUrn`, `authorId`, `authorProfileUrl`, `authorProfilePictureUrl`, `authorIsInfluencer`, `authorFollowerCount`
- **Timing**: `publishedAtMs` (Unix milliseconds), `publishedAtIso` (ISO 8601 UTC)
- **Engagement**: `totalReactions`, `commentsCount`, `repostsCount`
- **Reaction breakdown**: `reactionsBreakdown` — `{LIKE: 4521, EMPATHY: 234, PRAISE: 178, INTEREST: 92, ...}`
- **Tracking**: `sourceInput`, `scrapedAt`

#### `pulseComment` record (toggleable, ~12 fields)
When `includeComments=true`, the actor emits each article's top-level comments as separate `pulseComment` records:
- `articleUrn`, `articlePermalink` (back-references to the parent article)
- `commentPermalink`, `commentText`, `edited`
- `createdAtMs`, `createdAtIso`
- `commenterName`, `commenterHeadline`, `commenterProfileUrl`, `commenterProfilePictureUrl`, `commenterUrn`
- `reactionsCount`

Comments are returned in the **same vendor call** as the article body — no extra vendor cost.

Plus `diagnostic` (1 per failed profile) and `summary` (1 per run).

### Use cases (top 8)

#### 1. Thought-leadership monitoring — track competitor CEOs' long-form takes
Feed competitor CEOs' LinkedIn URLs. Get every recent Pulse article they've published. Track strategic themes, product launches, market positioning — long before they hit press releases.

#### 2. AI training data — long-form content from verified experts
Pulse articles are the highest-signal LinkedIn content type: verified authors, published intent, 3-50KB rich HTML. Ideal for training domain-specific language models on expert-authored content.

#### 3. Content marketing intelligence — analyze what resonates
Track 10-50 thought leaders in your industry. Compare which themes pull 1000+ reactions vs which fall flat. Build your content calendar from data.

#### 4. Investor research — founder/CEO archive
Pull every Pulse article from your target portfolio CEOs. Get a complete record of their public thinking before, during, and after fundraising.

#### 5. PR & analyst tracking — monitor industry analysts
Most B2B analysts (Gartner, IDC, Forrester) publish opinion pieces on Pulse. Track sentiment shifts on your category by name.

#### 6. Recruiting — signal-rich candidate research
Candidates who publish Pulse articles signal: communication skill, domain depth, willingness to be visible. Premium candidate-quality signal.

#### 7. Conference + event content sourcing
Many keynote speakers publish their talk content as Pulse articles after delivering. Build a searchable archive of conference-quality content.

#### 8. Historical archival
LinkedIn occasionally retires content. Backup important Pulse articles to your own dataset for compliance, citation, and reference.

### How it works

1. Set `profileUrls` — LinkedIn profile URLs (`https://www.linkedin.com/in/<username>/`) or bare usernames.
2. Set `maxArticlesPerProfile` (1-100, default 10).
3. Optionally enable `includeComments` (default false).

For each profile, the actor:
1. Resolves the profile URN.
2. Paginates `/articles/all` to collect article summaries (20 per page).
3. For each article, fetches the full content via `/articles/article/info`.
4. Emits a `pulseArticle` record per article. If `includeComments`, emits `pulseComment` records too (free — already in the same vendor response).

No login required. No cookies. Cookieless via managed vendor partnership — no account ban risk.

### Example input

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/",
    "williamhgates"
  ],
  "maxArticlesPerProfile": 5,
  "includeComments": true,
  "maxCommentsPerArticle": 10
}
````

Returns up to 10 `pulseArticle` records + up to 100 `pulseComment` records.

### Pricing — pay only for results

**$2.00 per 1,000 records. Pay-per-result.** *(Single flat rate across `pulseArticle` and `pulseComment` types.)*

- ✅ No subscription
- ✅ No monthly minimum
- ✅ No per-run start fee
- ✅ No charge for failed profiles (clean diagnostic record)
- ✅ Comments are FREE in vendor cost (same call as the article) — you only pay if you opt in to emit them as separate records
- ✅ Apify's free tier ($5/month platform credit) covers ~2,500 articles to start

**Why $2/1k?** This is **the only Pulse article scraper on Apify Store**. We could price it premium, but we'd rather drive adoption at a fair price that matches our other LinkedIn actors (a17 Profile at $2/1k). At $2/1k, a 1000-article archive of your top 20 industry thought leaders costs $2.

### Combine with other LinkedIn actors

Build a complete LinkedIn intelligence pipeline:

- Feed `authorProfileUrl` from `pulseArticle` into the **LinkedIn Profile Scraper** → enrich author context (current company, location, follower trends)
- Feed `activityUrn` from `pulseArticle` into the **LinkedIn Post Reactions Scraper** → get the actual list of reactors (not just counts)
- Feed `authorUrn` into the **LinkedIn Post Scraper** → also pull their short-form posts to round out the content picture

### FAQ

**Q: What's the difference between Pulse articles and posts?**
Posts are short-form (≤3,000 chars, often just a few sentences). Pulse articles are long-form (1,000-15,000+ words, full HTML content with formatting). Many CEOs, analysts, and thought leaders publish on Pulse but rarely on the regular feed.

**Q: How many Pulse articles can I get per author?**
The vendor returns up to ~100 historical articles per author. The `maxArticlesPerProfile` input caps at 100.

**Q: Does the `contentHtml` field include the full article body?**
Yes. The complete rendered HTML — paragraphs, headings, images, embedded links, lists — exactly as LinkedIn displays it on the Pulse page.

**Q: Are comments included by default?**
No — by default the actor emits only `pulseArticle` records. Set `includeComments: true` to also emit each article's top-level comments. There's no extra vendor cost (comments come in the same vendor response), only the cost of the additional `pulseComment` records you emit.

**Q: Can I scrape Pulse articles by company instead of by author?**
No — Pulse articles are always authored by individuals, not companies. Even when an article is "by Microsoft", the actual author is a Microsoft employee. Use `profileUrls`.

**Q: What about LinkedIn Newsletters?**
Newsletters are a related but separate content type. Coming soon as a dedicated **LinkedIn Newsletter Scraper**.

**Q: Is this safe to use vs my LinkedIn account?**
Yes. No login, no cookies, no browser session. The actor never authenticates as you.

### Privacy & compliance

This actor scrapes **publicly accessible LinkedIn Pulse articles** — the same content any logged-out visitor can read by browsing pulse.linkedin.com. Private/unlisted articles are not returned.

LinkedIn content may be subject to LinkedIn's Terms of Use and the article author's copyright. Customers are responsible for compliance with applicable laws (copyright, GDPR, CCPA) when storing or republishing scraped content.

Not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation.

# Actor input Schema

## `profileUrls` (type: `array`):

List of LinkedIn profile URLs (https://www.linkedin.com/in/<username>/) or bare usernames whose Pulse articles you want to scrape.

## `maxArticlesPerProfile` (type: `integer`):

Hard cap on how many Pulse articles to scrape per profile. Vendor returns up to ~100 historical articles per author.

## `includeComments` (type: `boolean`):

If on, emit each article's top-level comments as separate `pulseComment` records. Comments are included in the same vendor call as the article — no extra vendor cost.

## `maxCommentsPerArticle` (type: `integer`):

Cap on comments emitted per article when `includeComments` is on.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/"
  ],
  "maxArticlesPerProfile": 10,
  "includeComments": false,
  "maxCommentsPerArticle": 10
}
```

# 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 = {
    "profileUrls": [
        "https://www.linkedin.com/in/satyanadella/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/linkedin-pulse-article-scraper-no-cookies").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 = { "profileUrls": ["https://www.linkedin.com/in/satyanadella/"] }

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/linkedin-pulse-article-scraper-no-cookies").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 '{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/"
  ]
}' |
apify call linkedintel/linkedin-pulse-article-scraper-no-cookies --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Pulse Article Scraper · No Cookies · $2/1k ✅",
        "description": "The only LinkedIn Pulse article scraper on Apify Store. Full HTML content + engagement breakdown + author info per article. No cookies, no login. $2/1k pay-per-result.",
        "version": "1.0",
        "x-build-id": "CghV90wXH45faE4L9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~linkedin-pulse-article-scraper-no-cookies/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-linkedin-pulse-article-scraper-no-cookies",
                "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/linkedintel~linkedin-pulse-article-scraper-no-cookies/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-linkedin-pulse-article-scraper-no-cookies",
                "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/linkedintel~linkedin-pulse-article-scraper-no-cookies/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-linkedin-pulse-article-scraper-no-cookies",
                "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": [
                    "profileUrls"
                ],
                "properties": {
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "List of LinkedIn profile URLs (https://www.linkedin.com/in/<username>/) or bare usernames whose Pulse articles you want to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxArticlesPerProfile": {
                        "title": "Maximum articles per profile",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on how many Pulse articles to scrape per profile. Vendor returns up to ~100 historical articles per author.",
                        "default": 10
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "If on, emit each article's top-level comments as separate `pulseComment` records. Comments are included in the same vendor call as the article — no extra vendor cost.",
                        "default": false
                    },
                    "maxCommentsPerArticle": {
                        "title": "Max comments per article",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap on comments emitted per article when `includeComments` is on.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
