# LinkedIn Prospect Opener: Activity & Outreach Research (`fractionalhqforyou/linkedin-prospect-opener`) Actor

Read LinkedIn posting activity and get a draft opener grounded in a source post. Compare activity across runs and reuse existing records. Optional OpenAI generation; review every draft before sending.

- **URL**: https://apify.com/fractionalhqforyou/linkedin-prospect-opener.md
- **Developed by:** [Jessy Mariau](https://apify.com/fractionalhqforyou) (community)
- **Categories:** Lead generation, Social media, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 profiles

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## LinkedIn Prospect Opener: Activity & Outreach Research

Give every first message a reason to exist. Combine LinkedIn profiles and recent posts into a research table: who posted recently, which post drew the most engagement, and a draft opener with its source beside it.

The Actor prepares your research and draft. It sends no messages. Recent public activity does not tell you whether someone will see or answer an approach.

### See the result first

Leave profile URLs and optional records empty, then run. Three fictional profiles show ACTIVE, LAPSED and SILENT output without scraper calls, OpenAI calls or Actor event charges.

| Fictional person | Fictional company | Activity | Posts in 30 days |
| --- | --- | --- | --- |
| Priya Patel | Demo Ledger | ACTIVE | 3 |
| Tom Okafor | Demo Print Works | LAPSED | 0 |
| Hamish Grant | Demo Highland Haulage | SILENT | 0 |

These are actual outputs from the built-in fictional demo, not customer results. Open the dataset to inspect every reason, then export the rows as JSON, CSV or Excel.

### Cost of a real run

$0.015 per profile that returns data, including a found profile with no public posts and any supplied records. A 100-profile list costs $1.50 in this Actor's events; checking it weekly for four weeks costs $6.00. Profiles not found have no event charge.

Live profile and post reads run the two `harvestapi` Actors on your Apify account and add their per-profile and per-post charges. Your plan must permit them. Supply `records` to reuse existing data. Optional OpenAI generation is billed to your own OpenAI key. Check the Pricing tab and your Apify plan for current platform or standby usage costs.

### What I look at

For every profile I read the newest posts, reposts included, up to the number you set. From that set I work out:

**Activity class.** ACTIVE means they posted in the last 14 days. LAPSED means the last post was 15 to 60 days ago. SILENT means more than 60 days, or nothing at all.

**The numbers.** Last post date and posts in the last 30 and 90 days. Average reactions and average comments across the posts I read. How many were their own writing versus reposts.

**The top post.** The one with the most reactions and comments, their own posts first and reposts only when there is nothing else. You get its link, date, a 200 character excerpt and a topic guess from a keyword table: hiring, fundraising, product launch, AI, sales, marketing, leadership, event, customer story, career, personal, or general.

**The change since last time.** Every run saves a snapshot under the watch key you give it. Run the same list again with the same key and each row says NEWLY\_ACTIVE, WENT\_SILENT or UNCHANGED. The first run says BASELINE.

**The opener.** One line built from that person's own post. Without an OpenAI key it comes from a fixed template that names the topic, says when they posted it and quotes the first few words. With your key the model writes it instead, then I check it: at most 40 words, a phrase in quotation marks that really is in the post, none of the stock phrases people learn to skip, no dashes. A line that fails any of those is thrown away and the template goes out in its place. The row says which one you got.

### How to run it

Paste profile URLs, one per line. Set how many posts to read for each. Give the run a watch key if you plan to repeat it. Add your OpenAI key and a paragraph about what you sell if you want the model to write the openers. Run it, then open the Overview table and sort on the Change or Activity column.

Leave the list empty and you get three demo rows, one per activity class. The same code that handles real profiles builds them, so you see the shape of the output before you spend anything.

### What comes back

One row per profile. The profile scrape supplies the name and headline plus company, location and follower count. The activity block and the top post come from the posts. Then the opener, and a note if the model's line was rejected and why.

Three template openers from the demo run, so you know what the floor looks like:

> Priya, your hiring post this week stuck with me, the line "We just closed our Series A and the first" in particular, so I wanted to ask how that has played out since.

> Tom, your leadership post on 5 August stuck with me, the line "Ten years ago today I signed the lease on" in particular, so I wanted to ask how that has played out since.

> Hamish, your leadership post on 20 April stuck with me, the line "Grateful to the whole team for a record December" in particular, so I wanted to ask how that has played out since.

These are starting drafts for editing. The optional model version is checked for a matching phrase. That check does not verify the meaning of the complete sentence; review the linked post and edit the draft before sending.

I also write a summary record with the counts per class and per change, the ten people to write to first, and how many openers the model wrote versus how many fell back.

### Honest limits

- I only read the posts you asked for. Ask for ten and the averages describe those ten, not the person's whole history.
- A repost counts as activity, because someone who reposts weekly is still on the platform, but it is never the quoted post when the person has written anything of their own in the set.
- The topic guess is a keyword table. It is right often enough to sort a list by and wrong often enough that you should read the excerpt before you write.
- The template opener is deliberately plain. It exists so that a row without a key still has a line you can edit, and it should be edited.
- The model opener is checked for length, for a real quote, for the banned phrases and for dashes. It is not checked for taste. Read it before you send it.
- The posts Actor sometimes drops one profile from a batch and reports nothing wrong. When a profile comes back with no posts I ask for it once more on its own before calling anyone silent, and the row says so.
- A profile with no public posts still gets a row and an opener built from the headline, and it still counts as enriched if the profile itself was found.

### Use it from an AI agent

Want an agent to draft the opener for you? I run this Actor as an MCP server too, at `https://fractionalhqforyou--linkedin-prospect-opener.apify.actor/mcp`, exposing one tool named `open_linkedin_prospects` that takes your prospect list and returns the activity and the suggested first line. Agent calls cost the same per-event price. If your client cannot add a raw endpoint, use `apify/actors-mcp-server` with `fractionalhqforyou/linkedin-prospect-opener` in its list.

### Help with your first run

Open an issue on this Actor with the run ID and the result you expected. Remove API keys and private records before sharing. Built by [Fractional HQ](https://fractionalhq.uk), independent design and automation.

# Actor input Schema

## `profiles` (type: `string`):

One per line, for example https://www.linkedin.com/in/satyanadella. Up to 200 per run. Leave empty to get a demo dataset of three made-up profiles that charges nothing and runs no wrapped Actor.

## `postsToRead` (type: `integer`):

Posts are read newest first, including reposts. Activity, averages and the top post are all worked out from this set. Each post read is billed by harvestapi/linkedin-profile-posts to your own account.

## `pitchContext` (type: `string`):

Your paragraph is used by the LLM opener, and only as context: the line never pitches it. Ignored without an OpenAI key.

## `openaiApiKey` (type: `string`):

Your own key from platform.openai.com, stored as a secret. With it, each opener is written by the model and checked against the post; a line that breaks the rules falls back to the template. Without it, every opener is the template.

## `openaiModel` (type: `string`):

Any model on the Responses API.

## `watchKey` (type: `string`):

Names the saved activity snapshot this run compares against. Use the same key every time for the same list and each row says whether the person is NEWLY\_ACTIVE, WENT\_SILENT or UNCHANGED since last time. A new key starts a fresh baseline.

## `records` (type: `array`):

Paste raw items from harvestapi/linkedin-profile-posts and harvestapi/linkedin-profile-scraper you scraped earlier, in one array. They are enriched directly and no wrapped Actor runs.

## Actor input object example

```json
{
  "postsToRead": 10,
  "openaiModel": "gpt-5-mini",
  "watchKey": "default"
}
```

# Actor output Schema

## `prospects` (type: `string`):

One row per profile: name, headline, company, location, followers, activity class (ACTIVE, LAPSED, SILENT) with the change since the last snapshot, last post date, posts in 30 and 90 days, average reactions and comments, the most engaged post with its topic and a 200-character excerpt, and the opener with its source (template or llm).

## `summary` (type: `string`):

The OUTPUT record: profiles enriched, counts per activity class and per delta, the ten to write first with their opener, how many openers the model wrote and how many fell back, the inputs not found and the charged count.

# 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 = {
    "profiles": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("fractionalhqforyou/linkedin-prospect-opener").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 = { "profiles": "" }

# Run the Actor and wait for it to finish
run = client.actor("fractionalhqforyou/linkedin-prospect-opener").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "profiles": ""
}' |
apify call fractionalhqforyou/linkedin-prospect-opener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fractionalhqforyou/linkedin-prospect-opener"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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