LinkedIn Connection Request Message: Examples and When to Skip the Note

What you put in a LinkedIn connection request message matters less than most template lists suggest, and more than a blank box implies. This guide starts with what published data says about notes, then gives sixteen short examples by scenario and shows how to let AI draft one per person for you to review.

The short version. A note does not guarantee that more people accept: in several large published datasets, blank connection requests were accepted as often or slightly more often, while campaigns that used notes saw more replies. So add a note when you have something real and specific to say – what you share, something they did, why now – in one or two sentences under 200 characters, with no pitch. If you have nothing specific, send the request blank rather than a generic line. The examples below cover sales, recruiting and networking, and the last sections show how to let AI draft a note per person for you to review before anything is sent.

A note that works, after someone posts about a problem you also work on (162 characters):

Hi Maya – your post on onboarding emails that nobody opens matched what we see in our own data. I work on the same problem at Northwind. Would be glad to connect.

More by scenario: sales, recruiting and networking and job seekers.

Should you add a note to a LinkedIn connection request?

Only when it says something specific. The published numbers are observational campaign data, not controlled experiments, and they point the same way on acceptance:

HeyReach's help article reports 27% for blank requests against 22% with text, but states no sample, so read it as a vendor claim.

What this supports:

• A note does not guarantee more accepts. Blank requests did as well or better in these aggregates.
• Campaigns with notes were associated with more replies. Reachium cautions that the reply gap cannot be separated from the rest of the outreach sequence.
• Editorial guidance, not a measured result: be specific or send it blank, and never send a generic line.

Keep notes under 200 characters: LinkedIn lets a free account add a personalized message to three connection requests a month, and Premium members to all of them (LinkedIn Help). The full limits are in LinkedIn connection limits.

LinkedIn's own advice is "Keep your message short and specific". It says a good invitation usually includes "How you found the person or what you have in common", "Why you'd like to connect now", and "A clear and polite tone" (LinkedIn Help).

LinkedIn connection request message examples

Each example stays under 200 characters, so it fits a free account. The names and companies are invented, and the counts are for these real-length names – swap in your own specifics. The point is the one detail that could not be sent to anyone else. For more copy-paste ideas, the template libraries from Expandi, SalesRobot and Skylead are good starting points.

Sales and business development

Recruiting

Engaging candidates who are not looking is its own skill; the full sourcing workflow is in AI candidate sourcing on LinkedIn.

Networking and job seekers

When to send it blank: when their headline already makes the connection obvious, or when you cannot name one specific reason. A blank request beats "I'd like to add you to my professional network".

What makes a connection note work

This is editorial guidance drawn from LinkedIn's advice and the stronger template guides, not a measured result:

• One specific, checkable reference – a post, a project, an event, a person you both know.
• A reason to connect now – a new role, a conversation, something they just published.
• No pitch and no ask. The Muse's advice to job seekers applies to everyone: never ask for the job – or the meeting – in the note.
• No stock lines. "I'd like to add you to my professional network" tells them you did not look.
• The 500-people test. Outreachbloom's check: if the note could have been sent to 500 other people, it is not specific enough.
• Their name, used naturally – once, at the start, the way you would say it in person.
• Honesty matters. A recipient can choose "I don't know this person", which stops further invitations from you, and LinkedIn says that feedback helps it decide "whether we may need to restrict the sender's account" (LinkedIn Help).

Let AI draft each note from the profile – then review it

Writing a specific note for every person is where the time goes, and it is the part an AI model can draft well – if you give it the right inputs and keep a person in charge of sending.

Inputs for each person: their headline, current role and company, and one or two recent posts with their dates. Linked API reads these from the profile on your own LinkedIn account – fetchPerson with posts in code, or the fetch_person tool for an AI agent.

An illustrative prompt:

Draft a LinkedIn connection note for each person below. Rules: under 200 characters; mention one specific thing from their headline or recent posts, using only the text provided; no pitch and no meeting request; never invent facts. If nothing specific is there, answer SKIP and I will send the request without a note.

Then review every draft. Approve it, edit it, or mark it blank. The model writes; you decide what goes out under your name.

Hosted tools do this too: HeyLead drafts notes from profile signals, and Leonar puts the AI draft in front of a recruiter before it is pasted into LinkedIn. The route below is for when you want the draft-review-send loop on your own account, inside your own tools or agent. For the whole find, qualify and invite workflow around this step, see AI for sales prospecting; for notes around a sales call, see Claude for sales.

Send the approved notes at a human pace – from code or an agent

Once the drafts are approved, the sending step is mechanical. Linked API runs each request in your account's dedicated cloud browser at a human pace, within the per-account limits you set (admin limits), and reports LinkedIn's own answers as errors your workflow can act on (send connection request).

The script reads approved.json – each entry a personUrl and an approved note, or null for a blank request – and writes what happened to each one:

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

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

const SEND_BLANK_WHEN_OUT_OF_NOTES = true;

interface ApprovedRequest {
  personUrl: string;
  note: string | null;
}

type Outcome =
  | "sent"
  | "sent without note"
  | "already pending or connected"
  | "back to review"
  | "needs email"
  | "not allowed"
  | "unknown";

interface SendResult {
  personUrl: string;
  outcome: Outcome;
  detail: string;
}

async function send(personUrl: string, note: string | null): Promise<Array<TLinkedApiActionError>> {
  const workflow = await linkedapi.sendConnectionRequest.execute(
    note ? { personUrl, note } : { personUrl },
  );
  const { errors } = await linkedapi.sendConnectionRequest.result(workflow.workflowId);
  return errors;
}

async function sendOne(request: ApprovedRequest): Promise<SendResult> {
  const { personUrl, note } = request;
  try {
    const [error] = await send(personUrl, note);
    if (!error) {
      return { personUrl, outcome: note ? "sent" : "sent without note", detail: "" };
    }
    const { type, message } = error;
    switch (type) {
      case "noteLimitExceeded":
        if (SEND_BLANK_WHEN_OUT_OF_NOTES) {
          const [retryError] = await send(personUrl, null);
          return retryError
            ? { personUrl, outcome: "unknown", detail: retryError.message }
            : { personUrl, outcome: "sent without note", detail: "monthly note limit reached" };
        }
        return { personUrl, outcome: "back to review", detail: message };
      case "noteTooLong":
        return { personUrl, outcome: "back to review", detail: message };
      case "alreadyPending":
      case "alreadyConnected":
      case "invitationAlreadyReceived":
        return { personUrl, outcome: "already pending or connected", detail: type };
      case "emailRequired":
        return { personUrl, outcome: "needs email", detail: message };
      case "requestNotAllowed":
        return { personUrl, outcome: "not allowed", detail: message };
      default:
        return { personUrl, outcome: "unknown", detail: message };
    }
  } catch (caught) {
    if (caught instanceof LinkedApiError) {
      return { personUrl, outcome: "unknown", detail: caught.message };
    }
    throw caught;
  }
}

async function main(): Promise<void> {
  const approved: Array<ApprovedRequest> = JSON.parse(await readFile("approved.json", "utf8"));
  const results: Array<SendResult> = [];
  for (const request of approved) {
    const result = await sendOne(request);
    results.push(result);
    if (result.outcome === "not allowed") {
      break;
    }
  }
  await writeFile("results.json", JSON.stringify(results, null, 2));
  console.log(`${results.length} of ${approved.length} processed`);
}

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

import json
from pathlib import Path

from linkedapi import LinkedApi, LinkedApiConfig, LinkedApiError, SendConnectionRequestParams

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

SEND_BLANK_WHEN_OUT_OF_NOTES = True
DONE = ("alreadyPending", "alreadyConnected", "invitationAlreadyReceived")


def send(person_url: str, note: str | None) -> list:
    workflow = linkedapi.send_connection_request.execute(
        SendConnectionRequestParams(person_url=person_url, note=note or None)
    )
    return linkedapi.send_connection_request.result(workflow.workflow_id).errors


def send_one(person_url: str, note: str | None) -> tuple[str, str]:
    try:
        errors = send(person_url, note)
        if not errors:
            return ("sent" if note else "sent without note"), ""
        error = errors[0]
        if error.type == "noteLimitExceeded" and SEND_BLANK_WHEN_OUT_OF_NOTES:
            retry_errors = send(person_url, None)
            if retry_errors:
                return "unknown", retry_errors[0].message
            return "sent without note", "monthly note limit reached"
        if error.type in ("noteLimitExceeded", "noteTooLong"):
            return "back to review", error.message
        if error.type in DONE:
            return "already pending or connected", error.type
        if error.type == "emailRequired":
            return "needs email", error.message
        if error.type == "requestNotAllowed":
            return "not allowed", error.message
        return "unknown", error.message
    except LinkedApiError as caught:
        return "unknown", caught.message


approved = json.loads(Path("approved.json").read_text())
results = []
for request in approved:
    outcome, detail = send_one(request["personUrl"], request.get("note"))
    results.append({"personUrl": request["personUrl"], "outcome": outcome, "detail": detail})
    if outcome == "not allowed":
        break

Path("results.json").write_text(json.dumps(results, indent=2))
print(f"{len(results)} of {len(approved)} processed")

How it handles LinkedIn's answers:

• noteTooLong goes back to review. The approved note is never silently dropped.
• noteLimitExceeded means the account has used its personalized notes for the month. With SEND_BLANK_WHEN_OUT_OF_NOTES on, the request goes out without a note; turn it off to send those back to review instead.
• alreadyPending, alreadyConnected, invitationAlreadyReceived count as done, with no resend.
• emailRequired marks people who only accept requests with their email address.
• requestNotAllowed stops the batch. It can mean one person's settings, but it also covers reaching LinkedIn's sending limits, so carrying on would be the wrong move.
• A request or timeout error on one person is recorded as unknown and the run continues.

From the shell, the same step is linkedin connection send <url> --note "…" in the CLI. An AI agent with the MCP server or a ready-made skill can run the whole loop – read the profile with fetch_person, show you the drafts, and call send_connection_request only for the ones you approve. Keep that approval step in your prompt; the agent sends what you allow it to. What else an agent can run on your account is in LinkedIn AI agents.

The schedule and the review queue stay with you. After sending, checkConnectionStatus or network monitoring tells you who accepted before your first message. The sending mechanics are in how to automate LinkedIn connection requests, clearing old invitations is in LinkedIn pending invitations, and what to send after they accept is in LinkedIn cold outreach.

Frequently Asked Questions (FAQ)

Build it in, or hand it to an agent

Build the draft-review-send loop into your own CRM or outreach 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 – drafting from each profile 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 and the published acceptance datasets named here checked on that date.