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

Keyword-search LinkedIn Pulse articles across a curated list of authors. Returns articles matching the keyword in title or description. No cookies, no login. $1/1k per matching hit.

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

## Pricing

$1.00 / 1,000 search hit 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 Search Scraper — Keyword filter across curated authors

Keyword-search LinkedIn Pulse long-form articles **across a curated list of authors you specify**. For each author, the actor scans their Pulse archive and returns articles matching your keyword(s) in title or description. Clean structured JSON output. **No LinkedIn login, no cookies, no browser session, no account ban risk.**

Built for **competitive content intelligence, thought-leadership monitoring, AI training-data curation by topic, and content-trend tracking across a known audience**.

---

### Why curated-author search? — being honest about scope

Most LinkedIn search scrapers target **all of LinkedIn**. We tried to build that for Pulse — but LinkedIn auth-gates Pulse-specific search and discovery surfaces (`/pulse/discover`, `/pulse/topic/*`), and the vendor `/search/posts` endpoint returns only short-form posts (zero Pulse hits across every keyword we tested).

**So we built something honest instead: curated-author search.** You supply the authors you care about (CEOs, analysts, thought leaders); we scan their archives + filter by keyword. Narrower than "all of LinkedIn Pulse" but:

- ✅ Works today, fully cookieless
- ✅ Cheap: $1/1k matching hits
- ✅ Predictable cost (you control how many authors × how many articles to scan)
- ✅ Ideal for monitoring known thought leaders, not random discovery

---

### What you get — 1 record per matching article

For each author in `profileUrls`, the actor:

1. Resolves the profile URN
2. Paginates their Pulse archive (`/articles/all`)
3. Filters each article by keyword match against `title` + `description`
4. Emits a `pulseSearchHit` record for every match (up to `maxHitsPerAuthor`)

#### `pulseSearchHit` record (13 fields)
- **Matching info**: `matchedTerms` (which keywords hit), `positionInArchive` (0 = most recent)
- **Article**: `articleUrn`, `navigationUrl`, `title`, `description`, `duration`, `durationMinutes`, `coverImageUrl`
- **Author**: `authorUsername`, `authorProfileUrl`
- **Tracking**: `sourceInput`, `scrapedAt`

Plus `diagnostic` (1 per author with no matches) and `summary` (1 per run).

### Match modes

| Mode | Behavior | Example |
|---|---|---|
| `any` (default) | Article matches if **ANY** keyword hits | Keywords `"AI, agents"` → matches articles containing AI OR agents |
| `all` | Article matches only if **ALL** keywords hit | Keywords `"AI, agents"` → matches only articles containing both AI AND agents |

### Use cases (top 6)

#### 1. Track competitor CEO thought-leadership by topic
Feed 10-20 competitor CEO URLs + your category keyword (`"AI agents"`, `"climate tech"`, etc). Daily cron run surfaces every new article in the topic — alerts you to thematic content shifts in real-time.

#### 2. AI training data — curate domain-specific content
Feed 100 experts in your domain + topic keywords. Filter to articles where they wrote on your topic. Use `navigationUrl` to chain to the Pulse Article Scraper for full HTML content.

#### 3. Content marketing intelligence — what's resonating in your category
Compare keyword hit-rates across thought leaders. An author with 50% AI-articles signals investment depth. Useful for partnership scoring.

#### 4. Recruiting signal — domain depth via published content
Candidates who consistently publish on a topic (high hit-rate matching the topic) demonstrate domain depth. Useful for senior+ roles.

#### 5. Investor research — founder thesis-tracking
Feed portfolio CEO URLs + thesis keywords. See how their public writing evolves over time on the topics that matter.

#### 6. PR + analyst monitoring
Track named analysts/journalists' Pulse output for mentions of your company, product, or category. Surfaces commentary you'd miss in mainstream press.

### How it works

1. Set `profileUrls` — LinkedIn profile URLs (`https://www.linkedin.com/in/<username>/`) or bare usernames whose archives to search.
2. Set `keywords` — comma-separated terms to match against article title + description.
3. Choose `matchMode` (`any` or `all`).
4. Set `maxArticlesToScanPerAuthor` (1-500, default 50) and `maxHitsPerAuthor` (1-500, default 50).

For each author: resolve URN → paginate `/articles/all` (20 per page) → filter each article → emit matching hits.

No `/articles/article/info` calls — just `/urn` + `/articles/all`. **No vendor cost per matched article beyond the page-pagination.**

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",
    "reidhoffman"
  ],
  "keywords": "AI, agents, future",
  "matchMode": "any",
  "maxArticlesToScanPerAuthor": 50,
  "maxHitsPerAuthor": 20
}
````

For 3 authors × 50 articles scanned × matching ~20% → roughly 30 hits → cost: **$0.03 total at $1/1k**.

### Pricing — pay only for matching hits

**$1.00 per 1,000 matching hits. Pay-per-result.**

- ✅ No subscription
- ✅ No charge for non-matching articles (we scan them for free; only matching hits are billed)
- ✅ No charge for authors with zero matches (clean diagnostic record)
- ✅ Apify's free tier ($5/month platform credit) covers ~5,000 hits to start
- ✅ Predictable cost: capped by `maxHitsPerAuthor × number_of_authors`

**Cost comparison:**

| Tool | 1,000 hits | Pulse-aware? |
|---|---|---|
| LinkedIn Search Scraper (a20) POSTS entity | $1.50/1k | ❌ (returns regular posts only, no Pulse content) |
| harvestapi / supreme\_coder / others | — | ❌ (no Pulse search) |
| **This actor** | **$1.00/1k** | ✅ explicit Pulse |

### Combine with other LinkedIn actors

Build a multi-stage pipeline:

1. **This actor (p6)** → filter by keyword across N authors, surface matching articles
2. **LinkedIn Pulse Article Scraper (p1)** → pipe `navigationUrl` for full HTML + engagement on selected hits
3. **LinkedIn Pulse Comments Scraper (p2)** → comments on high-engagement matching articles
4. **LinkedIn Pulse Reactions Scraper (p3)** → reactor lists for content-intent signals
5. **LinkedIn Profile Scraper (a17)** → enrich the article authors with full firmographic data
6. **LinkedIn Pulse Author Archive (p4)** → if you need to expand the curated-author list before searching

### FAQ

**Q: Can I search ALL of LinkedIn Pulse without specifying authors?**
No — that requires LinkedIn's auth-gated search APIs which no LinkedIn-data vendor exposes today. Build a curated author list from **LinkedIn Search Scraper (a20)** with `entityType=PEOPLE` and a topic-related title filter, then feed those usernames here.

**Q: Why does the match check only title + description, not full content?**
Article body HTML is only available via the more expensive `/articles/article/info` call ($2/1k via Pulse Article Scraper). We do title + description matching cheap, then customer chains to p1 for content matching on selected hits.

**Q: How are keywords combined when matchMode=any vs all?**
ANY: matches if at least one keyword appears. ALL: matches only if every keyword appears. Use ALL for narrow targeted searches, ANY for broader topic monitoring.

**Q: Are matches case-sensitive?**
No — all matching is case-insensitive. `AI` will match `ai`, `AI`, `Ai`, etc.

**Q: What if an author has 0 articles?**
The actor emits a `diagnostic` record for that author and moves on. Other authors in the batch proceed normally.

**Q: Can I see WHICH article positions matched?**
Yes. Each `pulseSearchHit` has `positionInArchive` (0 = most recent). Useful for trend tracking.

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

### Privacy & compliance

This actor scrapes **publicly accessible LinkedIn Pulse article listings** — the same titles + descriptions any logged-out visitor can see on a profile's articles tab.

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

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

# Actor input Schema

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

LinkedIn profile URLs (https://www.linkedin.com/in/<username>/) or bare usernames whose Pulse archive to search.

## `keywords` (type: `string`):

Comma-separated keywords to match against article title + description (case-insensitive). Example: 'AI, machine learning, agents'

## `matchMode` (type: `string`):

ANY → article matches if any keyword hits. ALL → article must contain every keyword.

## `maxArticlesToScanPerAuthor` (type: `integer`):

How many of the author's most recent Pulse articles to scan for keyword match. Vendor returns up to ~500.

## `maxHitsPerAuthor` (type: `integer`):

Hard cap on matching articles emitted per author. Reduces cost when you only need top-N matches.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/",
    "williamhgates",
    "reidhoffman"
  ],
  "keywords": "AI, agents, machine learning",
  "matchMode": "any",
  "maxArticlesToScanPerAuthor": 50,
  "maxHitsPerAuthor": 50
}
```

# 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/",
        "williamhgates",
        "reidhoffman"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/linkedin-pulse-search-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/",
        "williamhgates",
        "reidhoffman",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/linkedin-pulse-search-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/",
    "williamhgates",
    "reidhoffman"
  ]
}' |
apify call linkedintel/linkedin-pulse-search-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-search-scraper-no-cookies",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Pulse Search Scraper · No Cookies · $1/1k ✅",
        "description": "Keyword-search LinkedIn Pulse articles across a curated list of authors. Returns articles matching the keyword in title or description. No cookies, no login. $1/1k per matching hit.",
        "version": "1.0",
        "x-build-id": "eJzIudTwzgtm3R9jh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~linkedin-pulse-search-scraper-no-cookies/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-linkedin-pulse-search-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-search-scraper-no-cookies/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-linkedin-pulse-search-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-search-scraper-no-cookies/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-linkedin-pulse-search-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",
                    "keywords"
                ],
                "properties": {
                    "profileUrls": {
                        "title": "Author profile URLs",
                        "type": "array",
                        "description": "LinkedIn profile URLs (https://www.linkedin.com/in/<username>/) or bare usernames whose Pulse archive to search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Comma-separated keywords to match against article title + description (case-insensitive). Example: 'AI, machine learning, agents'"
                    },
                    "matchMode": {
                        "title": "Match mode",
                        "enum": [
                            "any",
                            "all"
                        ],
                        "type": "string",
                        "description": "ANY → article matches if any keyword hits. ALL → article must contain every keyword.",
                        "default": "any"
                    },
                    "maxArticlesToScanPerAuthor": {
                        "title": "Max articles to scan per author",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many of the author's most recent Pulse articles to scan for keyword match. Vendor returns up to ~500.",
                        "default": 50
                    },
                    "maxHitsPerAuthor": {
                        "title": "Max matching hits per author",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on matching articles emitted per author. Reduces cost when you only need top-N matches.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```