How to Engage Passive Candidates: A Research-First LinkedIn Playbook

To engage passive candidates – people who are not applying for jobs but would move for the right role – you need a reason that is about them, not a job ad. This guide covers who counts as passive, why most recruiter messages get ignored, what to research before the first touch, a follow-up sequence to test, and how to let an AI agent do the research and drafting while a recruiter approves every message.

The short version. Passive candidates are people who are not applying for jobs but would consider the right move – in Gallup's late-2025 poll, 40% of U.S. employees were watching for opportunities without actively looking, against 11% actively searching. They answer a specific reason, not a job ad. So research each person before the first touch – a recent post, a career move, a project – and pair one true detail about them with one real detail about the role: the problem, the setup, the pay you can share. Reach them through the channel your relationship allows. A sensible starting point to test is a first message once they accept, then two follow-ups about a week apart, stopping the moment they reply. When someone says "not now", agree when to come back. An AI agent can do the per-person research and draft each message from your role brief, as long as a recruiter approves every message before it goes out.

What is a passive candidate?

A passive candidate is someone who is employed, not applying for jobs, and open to the right move. Active candidates are the opposite: they search and apply. Gallup asks U.S. employees the question directly – "To what extent are you currently looking for a different job than the one you have now?" – and the answers split like this:

The shares come from Gallup's poll of 22,368 U.S. employees, fielded October 30 – November 13, 2025 (Gallup); its tracker put the combined share watching or actively seeking at 53% in August 2026 (Gallup). Gallup measures whether people are looking, not whether they will answer a recruiter – the third column is our reading, not Gallup's.

The figure most articles quote – "70% of the global workforce is passive talent" – comes from LinkedIn's 2015 Global Talent Trends survey of 20,931 members. It is more than ten years old, so use it with its date.

Why passive candidates ignore recruiter messages

LinkedIn's own data on recruiter InMails points at the usual reasons:

• Bulk messages. "InMails that are sent individually see response rates roughly 15% higher than InMails sent in bulk" – from LinkedIn's analysis of tens of millions of recruiter InMails sent between May 2021 and April 2022 (LinkedIn Talent Blog).
• Long messages. "The response rate for the shortest InMails is 22% higher than the average response rate for all InMails" – the shortest being under 400 characters (same study).
• No connection to the company. "Candidates are 46% more likely to accept an InMail if they're already connected to someone at your company" (LinkedIn Talent Blog).

The rest is editorial, but consistent with that data: a pasted job description, no reason why this person, a message in their busiest month, and follow-ups that never stop.

Where to find passive candidates on LinkedIn

Search cannot tell you who is open. Standard and Sales Navigator search have no job-seeking filter, and a member's recruiters-only Open to Work setting is visible only to people using LinkedIn Recruiter (LinkedIn Help) – so a profile without the green frame tells you nothing. Search by role, current and past company, school and location, then judge from the profile.

Turning a vacancy into that search and an evidence-backed shortlist is covered in AI candidate sourcing on LinkedIn; search operators are in LinkedIn Boolean search, and mapping a whole market is in talent mapping for recruitment. This guide starts where the shortlist ends.

Research each person before the first touch

What you can say depends on what the profile shows. This table is editorial guidance:

Done by hand, this takes minutes per person – Juicebox's guide budgets five to ten minutes for each top-tier candidate. That reading and the first draft are the parts to hand to an AI agent, further down.

How to reach passive candidates: the first message and the follow-ups

The channel depends on your relationship:

• Already connected (1st degree): send a message.
• 2nd or 3rd degree: send a connection request – with a note only when you have a specific reason – and message once they accept. A free account can add a note to three requests a month, up to 200 characters; Premium removes the monthly cap (LinkedIn Help). Recruiting note examples are in LinkedIn connection request message examples.
• Outside your network, on a paid plan: InMail needs Premium, Sales Navigator or Recruiter, and runs on credits that come back when the recipient accepts, declines or replies within 90 days (LinkedIn Help) – the details are in the LinkedIn InMail guide.

What the first message carries:

1. One true detail about them – the post, the project, the move.
2. One verified detail about the role that connects to it – the actual problem, the setup (remote, hybrid, location), the pay you are allowed to share. LinkedIn's Talent Blog lists what candidates weigh: "Compensation", "Career and personal growth opportunities", "Intrinsic enjoyment of the work", "Professional autonomy", "Flexible work opportunities" and "Mission and values alignment".
3. Why now, in a clause.
4. One small ask – a 15-minute call, not a CV.

A starting cadence to test

This is editorial guidance, not a measured LinkedIn schedule:

1. Connection request – a note only if you have a specific reason.
2. The first message, once they accept.
3. Follow-up one, about a week later, adding something new – a detail about the team, or an answer to a question their post raised.
4. Follow-up two, about a week after that – a short close-the-loop.
5. Stop. Any reply – yes, no or later – ends the sequence.

The published follow-up data comes from email, not LinkedIn. In Gem's analysis of over 4 million recruiting email sequences (March 2023 – February 2024), the cumulative reply rate rose from 11.7% after the first email to 22.6% after the fifth and then flattened; recruiters typically waited six days between emails. Ashby's analysis of 500,000+ email sequences (January 2022 – January 2024) found replies plateau around 23% after three emails, with most campaigns spacing emails four days apart. And in LinkedIn's InMail study, 90% of the responses that arrived came within a week. None of this tests a LinkedIn sequence – it is why a week between touches and a stop after the third message are a reasonable place to start.

One worked sequence

For an invented candidate, Wei, a staff data engineer at Fabrikam who posted about moving the team's pipeline to Flink, and an invented role at Northwind that owns the same migration:

The first message pairs Wei's post with the role's real problem, its setup and its pay band, and asks for one small thing. Nothing in the sequence is a pasted job description.

Let an AI agent research and draft – you approve every message

The research and the first draft are where the time goes, and both suit an AI model – if it gets the right inputs and a recruiter keeps the send button.

Two inputs:

• A role brief you write once per vacancy – the company, the actual problem or scope, location and workplace arrangement, the compensation you are allowed to share, and what makes the role worth a move.
• Evidence per person – current roles with months in each, earlier roles, and recent posts with their dates. Linked API reads these from the profile on your own LinkedIn account: fetchPerson with experience and posts in code, below, or the fetch_person tool for an AI agent.

An illustrative prompt:

You draft LinkedIn recruiting messages. Inputs: one role brief and one research packet per person. For each person, write a connection note (under 200 characters, or blank), a first message (under 400 characters) and two short follow-ups. Rules: use only facts from the role brief and the packet, and never invent; tie one true detail about the person to one verified detail about the role; no salary or benefits that are not in the brief, and no pasted job description; one small ask. If nothing in the packet links this person to this role, answer SKIP.

Then review every draft. A recruiter reads each one and approves, edits or skips it before anything is sent. LinkedIn builds its own tool the same way: with AI-Assisted Messages in Recruiter, "you are responsible for reviewing the message draft for accuracy and making any necessary edits" (Recruiter Help).

Hosted tools draft recruiting messages too, with different review steps:

Build the research step in code – or let an agent run it

The script reads shortlist.json – the profile URLs from your shortlist – and writes one research packet per person to packets.json for the drafting step: name, headline, every current role with months in it, and original posts from the last 90 days with their dates.

import { readFile, writeFile } from "node:fs/promises";
import LinkedApi, { LinkedApiError } from "@linkedapi/node";

const linkedapi = new LinkedApi({
  linkedApiToken: "your-linked-api-token",
  identificationToken: "your-identification-token",
});

const POSTS_SINCE = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString().replace(/\.\d{3}Z$/, "Z");

interface CurrentRole {
  position: string;
  companyName: string;
  monthsInRole: number;
}

interface RecentPost {
  time: string;
  url: string;
  text: string;
}

interface ResearchPacket {
  personUrl: string;
  status: "researched" | "partial" | "retry";
  name?: string;
  headline?: string;
  currentRoles?: Array<CurrentRole>;
  recentPosts?: Array<RecentPost>;
  detail?: string;
}

async function research(personUrl: string): Promise<ResearchPacket> {
  try {
    const workflow = await linkedapi.fetchPerson.execute({
      personUrl,
      retrieveExperience: true,
      retrievePosts: true,
      postsRetrievalConfig: { limit: 5, since: POSTS_SINCE },
    });
    const { data, errors } = await linkedapi.fetchPerson.result(workflow.workflowId);
    if (!data) {
      const [error] = errors;
      return { personUrl, status: "retry", detail: error ? error.message : "no profile data" };
    }
    const { name, headline, experiences = [], posts = [] } = data;
    const detail = errors.map(({ message }) => message).join("; ");
    return {
      personUrl,
      status: detail ? "partial" : "researched",
      name,
      headline,
      currentRoles: experiences
        .filter((role) => role.endTime === null)
        .map(({ position, companyName, duration }) => ({ position, companyName, monthsInRole: duration })),
      recentPosts: posts
        .filter((post) => post.type === "original" && post.text)
        .map(({ time, url, text }) => ({ time, url, text: text ?? "" })),
      detail,
    };
  } catch (caught) {
    if (caught instanceof LinkedApiError) {
      return { personUrl, status: "retry", detail: caught.message };
    }
    throw caught;
  }
}

async function main(): Promise<void> {
  const shortlist: Array<string> = JSON.parse(await readFile("shortlist.json", "utf8"));
  const packets: Array<ResearchPacket> = [];
  for (const personUrl of shortlist) {
    packets.push(await research(personUrl));
  }
  await writeFile("packets.json", JSON.stringify(packets, null, 2));
  const toCheck = packets.filter((packet) => packet.status !== "researched").length;
  console.log(`${packets.length - toCheck} researched, ${toCheck} to check or retry`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

import json
from datetime import datetime, timedelta, timezone
from pathlib import Path

from linkedapi import FetchPersonParams, LimitSinceParams, LinkedApi, LinkedApiConfig, LinkedApiError

linkedapi = LinkedApi(
    LinkedApiConfig(
        linked_api_token="your-linked-api-token",
        identification_token="your-identification-token",
    )
)

POSTS_SINCE = (datetime.now(timezone.utc) - timedelta(days=90)).strftime("%Y-%m-%dT%H:%M:%SZ")


def research(person_url: str) -> dict:
    try:
        workflow = linkedapi.fetch_person.execute(
            FetchPersonParams(
                person_url=person_url,
                retrieve_experience=True,
                retrieve_posts=True,
                posts_retrieval_config=LimitSinceParams(limit=5, since=POSTS_SINCE),
            )
        )
        result = linkedapi.fetch_person.result(workflow.workflow_id)
        person = result.data
        if person is None:
            detail = result.errors[0].message if result.errors else "no profile data"
            return {"personUrl": person_url, "status": "retry", "detail": detail}
        detail = "; ".join(error.message for error in result.errors)
        return {
            "personUrl": person_url,
            "status": "partial" if detail else "researched",
            "name": person.name,
            "headline": person.headline,
            "currentRoles": [
                {"position": role.position, "companyName": role.company_name, "monthsInRole": role.duration}
                for role in person.experiences or []
                if role.end_time is None
            ],
            "recentPosts": [
                {"time": post.time, "url": post.url, "text": post.text}
                for post in person.posts or []
                if post.type == "original" and post.text
            ],
            "detail": detail,
        }
    except LinkedApiError as caught:
        return {"personUrl": person_url, "status": "retry", "detail": caught.message}


shortlist = json.loads(Path("shortlist.json").read_text())
packets = [research(person_url) for person_url in shortlist]
Path("packets.json").write_text(json.dumps(packets, indent=2, ensure_ascii=False))
to_check = sum(1 for packet in packets if packet["status"] != "researched")
print(f"{len(packets) - to_check} researched, {to_check} to check or retry")

How to read the packets:

• Every current role is kept. A person can hold more than one, so the packet lists them all instead of guessing which matters.
• partial means the profile came back but part of it did not – the posts, say – so an empty post list is not mistaken for a quiet profile.
• retry covers a profile that could not be read and a request that failed or timed out; the run carries on with the next person.

Approved notes and messages go out with sendConnectionRequest and sendMessage, each run in your account's dedicated cloud browser at a human pace, within the per-account limits you set (admin limits). The full send loop, with LinkedIn's note errors handled, is in the connection request message guide, and message mechanics are in how to automate LinkedIn messages. To stop the follow-ups when someone answers, inbox monitoring sends a webhook event for each new message – mark that person as replied and drop their pending follow-ups.

An AI agent with the MCP server, the CLI or a ready-made skill can run the same loop from a plain-language ask: read each profile with fetch_person, show you the drafts against your role brief, and call send_connection_request or send_message only for the ones you approve. Keep that approval step in your instructions. What else an agent can run on your account is in LinkedIn AI agents.

Read only what the message needs. The privacy note in the talent mapping guide applies here too.

Keep "not now" candidates warm

• Agree when to come back. Ask what is holding them back; the date should come from them, not from a fixed interval.
• LinkedIn's examples, not a rule. Its Talent Blog suggests that for someone waiting to launch a major project or reach a personal milestone, "you might reach out in six months to a year to follow up", and for someone who just started a new job, a year or two.
• Re-read the profile before you return. A new role, a new post or a finished project is the next reason to write.
• Keep them in view. Network monitoring shows who accepted your requests, so "not now" contacts stay in your network where their updates reach you.

Frequently Asked Questions (FAQ)

Build it in, or hand it to an agent

Build the research, draft, review and send loop into your ATS, CRM or recruiting tool with the REST API, the Node and Python SDKs or the shell CLI. Or have an AI agent run it out of the box through the MCP server, the agent-friendly CLI or a ready-made skill – researching each candidate, drafting against your role brief and sending only what you approve, on your own LinkedIn account. Plans are flat per seat, from $49/mo billed annually – see pricing.

Facts verified November 2, 2026 – LinkedIn Help pages, LinkedIn's published InMail data, Gallup and the vendor pages named here checked on that date.