Recruitment Business Development: How Agencies Win Clients on LinkedIn

Recruitment business development is how a recruitment or staffing agency wins new clients and more work from the ones it has – not the job of hiring business development staff. This guide covers where agency clients come from, a weekly routine for finding and approaching them on LinkedIn, how to turn a reply into a job order, and how an AI agent can run the research on your own account.

The short version. Recruitment business development is how an agency wins and grows clients: new accounts, new job orders and repeat work. On LinkedIn it works best as a weekly routine. Pick a niche you can fill, find companies that are hiring in it, find the people behind the hire – the manager who needs the role filled and whoever can bring in an agency, which differs by company – and open with a reason tied to that role: the vacancy itself, a candidate you could put forward, or a recent change at the company. Follow up once and stop when they reply. A reply is not a client yet: on the call, agree the need, the urgency, who signs off and the terms, then record the job order. Count meetings and job orders, not messages sent, and run the same check on your existing clients' new roles. A job ad is a noisy lead – the role may already be with other agencies or run by an internal recruiter – so check how long it has been open and who owns it before you write. An AI agent can do the research and draft every touch on your own LinkedIn account, while you approve each message and keep the calls and the relationship.

What is recruitment business development?

Recruitment business development (BD) is the work of winning client accounts and new job orders, as opposed to finding the candidates who fill them. Loxo's definition covers the whole span: "identifying potential clients, engaging them, getting them to do business with you, taking their job orders, maintaining excellent relationships".

In agency language, a 360 recruiter does both halves – wins the job order and fills it.

Where do recruitment agencies find new clients?

Most agencies mix several channels. The table sums up how each works and what practitioners warn about; it is practitioner advice, not measured data.

Citable benchmarks are scarce here: the research for this guide found no primary study of agency-to-client reply rates, so this guide quotes none. Set your own baseline in the first month instead (see measurement).

The weekly BD loop on LinkedIn

1. Pick a niche you can actually fill.
2. Find companies that are hiring in it this week.
3. Find the people behind the hire.
4. Send one relevant touch – a note tied to the role or the change.
5. Follow up once, and stop when they reply.
6. Turn the reply into a qualified job order.
7. Log meetings and job orders, not messages.

Steps 2 and 3 are the slow part – reading job posts, company pages and profiles for every account. That is the part an AI agent can take over.

Pick a niche where hiring demand is growing

Practitioners agree on this one. "Generalist staffing firms compete on price; niche firms compete on knowing the market," as Pin's guide puts it, and Agency Leads' playbook says "A successful recruitment BD strategy is always vertical-specific." Your niche is where you already have candidates and market knowledge.

For a sanity check on demand, LinkedIn and the American Staffing Association track paid LinkedIn job postings published by staffing and recruiting firms in the US. Year-over-year change, as of June 2025 (The State of Staffing & Search, February 2026):

These are paid postings by staffing firms themselves (their own corporate roles excluded), so they show where agencies already see demand – not where clients go unserved. Use the table to confirm a niche, not to jump to a new one. If you pitch for retained or exclusive work in that niche, a market map is a strong asset – see our talent mapping guide.

How to find companies that are hiring on LinkedIn

LinkedIn's job search is the raw material: every post names a company, a role, a location and a date. The filters that matter for BD (LinkedIn Help):

LinkedIn is also rolling out an AI-powered job search beside the classic one. The two offer different refinements, and which one an account sees is LinkedIn's choice, so a filter may need its AI-search equivalent (two versions of LinkedIn jobs search).

Read the post before you act on it:

• How long it has been open. A reposted job "will be treated as a new job" (LinkedIn Help), so a fresh date can hide an old role. Leonar's agency guide treats roles open for 30 days or more as the stronger signal.
• Whether the search is live. "Actively Reviewing Applicants" appears "when the recruiter has reviewed one or more applications in the past two weeks" (LinkedIn Help).
• Applicant count and salary, when the post shows them.
• Who posted it. Skip roles posted by other agencies.

The catch. A visible job ad is visible to every agency. In a Reddit thread on BD in r/Recruitment, a headhunter described messaging companies that advertise roles on LinkedIn, and one reply was: "To join 30 recruiters on every role". A job ad gives you a reason to talk, not a client.

A second source of signals on Sales Navigator. Hiring is one of several buying signals on LinkedIn, and Sales Navigator account alerts flag changes such as a company hiring a senior decision maker. Linked API reads them with nv.retrieveAlerts from the feed Sales Navigator currently shows you; Linked API does not store alerts or send alert webhooks, so you check on a schedule and remember which alerts you have seen.

How to find the hiring manager behind a job post

On a LinkedIn job page, members can see a "Meet the Hiring Team" section that includes the job poster (LinkedIn Help), when the poster chooses to display their profile on the post (LinkedIn Help). That person is often not who you want: TheirStack's documentation on job posters warns that "in many cases this is just the recruiter that has posted the position and not the future manager of the hired person in the company."

Aim for two people: the manager who needs the role filled, and whoever can engage an agency. At a small company that is often the same founder or head of the team; at a larger one, talent acquisition or procurement may own agency relationships. LinkedIn's own advice for agency BD is to "Reach out to key decision-makers who are actively #Hiring" (Recruiter Help). Practitioners on forums often say "skip HR" – treat that as one view, not a rule.

To find them, search the company's people by the title that runs the function – Head of Data for a data engineer, Finance Director for a payroll manager – and check who you are already connected to there, 1st degree first. Treat everyone this turns up as a possible contact until you have checked: a title does not prove who owns this vacancy. The job post, the person's recent posts or a short question settles it. Our LinkedIn company scraper guide covers reading a company's employees and decision makers, and the B2B buying committee guide covers mapping several people at one account.

What to send: a connection note and one follow-up

The channel depends on your connection:

• 1st degree – a message.
• 2nd or 3rd degree – a connection request. A free account can add a personalized note to "up to three connection requests per month", each "up to 200 characters"; Premium members can personalize every invitation (LinkedIn Help). More examples are in our connection request message guide.
• InMail – a Premium, Sales Navigator or Recruiter feature with monthly credits (LinkedIn Help); see the InMail guide.

Every touch should carry one reason tied to this company now, one detail you can stand behind – a candidate you actually represent, a market fact – and one small ask. Pin's guide sums it up: "Pitch the role, not the agency." Three examples, all for invented companies:

1. A job-ad response (176 characters):

Hi Dana – saw Northwind is hiring a Senior Data Engineer in Berlin. I place data engineers in Berlin fintech and have two people in process who fit. Worth 15 minutes this week?

Follow-up, once connected:

Thanks for connecting, Dana. Most data engineers I speak to in Berlin ask first about hybrid days and the stack. If it helps, I can share what candidates are asking for right now – 15 minutes on Thursday?

2. A candidate you could put forward (177 characters):

Hi Marco – I'm representing a payroll manager (8 years, multi-country, ADP) who is open to roles in Milan. With your finance team growing, would an anonymised profile be useful?

Follow-up:

Marco, the payroll manager I mentioned has had a second interview elsewhere, so the window is short. The anonymised profile is ready if you want to see it – no commitment.

3. A signal: a new senior leader (178 characters):

Congrats on the new role, Priya. New CTOs often reshape the platform team early on – I recruit platform engineers in London and put together a short salary snapshot. Want a copy?

Follow-up:

Priya, here is the snapshot I mentioned: base ranges for senior platform engineers in London this quarter. If the team plan changes, I'm happy to talk through the market.

A starting cadence to test (editorial guidance): a connection request, with a note only when you have a specific reason; a message once they accept; one follow-up about a week later that adds something new; then stop. Any reply stops the sequence. Keep it targeted – a handful of 1:1 touches per niche each week, never a bulk send.

Turn a reply into a job order

A reply is a conversation, not a client. The first call decides whether there is work and on what terms. A checklist (editorial guidance):

• The need: the role, why it is open, why now.
• Urgency and timeline: when they need someone in seat, and what happens if they don't.
• Budget: the salary band, and whether the budget for an agency fee exists.
• Who can engage an agency: who signs off, and whether there is an approved-supplier (PSL) process you would need to join.
• Competition: which other agencies or internal recruiters are already working the role.
• The brief and the terms: what a strong candidate looks like, the fee, exclusivity if any.
• The next step: a dated action – a shortlist by Friday, a signed agreement, a call with the hiring manager.

Then record the opportunity, the brief and the next step in your CRM or ATS – that stays your system of record. An agent can turn your call notes into a summary; it does not own the deal.

Grow existing clients

Once a week, run the same job search filtered to the companies you already work with or have placed into, and check Sales Navigator alerts on saved client accounts for a new senior leader or a growing team. When a client opens a new role, write to the manager you placed for before the post collects other agencies. After a placement, check in and ask who else is hiring. For deciding which clients deserve that attention, the tiering in our account-based selling guide applies to agencies too.

Let an AI agent run the research – you approve every message

The slow part of BD is research, and it is exactly what an agent can do on your own LinkedIn account. It needs two inputs from you:

• A niche brief, written once: the roles and locations you fill, the candidates you have on hand, what makes your agency worth a call, and who not to approach – existing clients, companies you place candidates into from.
• The weekly job search: the terms and filters above.

The agent's weekly routine: search the niche's jobs; open each job for its company, posted date, applicant count and description; drop roles posted by agencies and roles you cannot fill; read each company's people for the head of the function and your 1st-degree contacts; read one or two profiles; draft a note and a follow-up per account – or SKIP; show you the drafts; send only the ones you approve; and stop the follow-up when someone replies.

An illustrative delegation prompt:

Every Monday, using my niche brief below:

1. Search LinkedIn jobs posted in the past week for [roles] in [locations].

2. Open each job. Drop it if a staffing or recruiting agency posted it, or if the company is on my do-not-approach list.

3. For each remaining company, read up to 10 employees whose title matches the head of that function and its top 5 decision makers. Mark my 1st-degree connections.

4. Read the profiles and recent posts of the one or two most likely owners. Treat them as possible contacts, not confirmed owners.

5. Draft one connection note under 200 characters and one follow-up per company, using only facts from the job post, the company page and the profiles. Mention a candidate only if they are on my candidate list. Never mention fees or terms. If nothing specific links my agency to the company, write SKIP.

6. Show me the drafts in a table. Send only the ones I approve.

7. If anyone replies, stop their follow-up and tell me.

The review gate lives in your prompt or your code. Linked API has no built-in approval queue or sequence engine: nothing is sent unless your agent or code calls a send action, so "draft, show, send only what I approve" is a rule you give the agent. LinkedIn's own BD tooling for agencies says the same: "Review and personalize AI-generated messages before sending" (Recruiter Help).

What the agent cannot do here:

• return the job poster – read "Meet the Hiring Team" on the page yourself;
• find emails or phone numbers;
• write to your CRM, unless your agent also has a CRM tool;
• give an exhaustive count for a role or niche – search and employee results are capped lists.

It does read each company's own totals: the number of employees and the number of current vacancies the company has posted, a quick check of size and hiring activity per account.

How the agent reaches LinkedIn. Out of the box, through the MCP server – tools such as search_jobs, fetch_job, fetch_company, fetch_person, send_connection_request, send_message and nv_retrieve_alerts (full list) – or the AI-agent-friendly CLI (linkedin jobs search, linkedin jobs fetch, linkedin company fetch), with ready-made skills covering the people, company and messaging steps. Or build it in, with the REST API, the Node and Python SDKs and the shell CLI. For how agents connect to a LinkedIn account in general, see our LinkedIn AI agent guide; for agents on the candidate side, see the AI recruiting agent guide.

Build the research step in code

If you would rather run the research in your own code, the step from a job to the people behind it is short. It reads jobs.json – entries of { "jobUrl": "...", "ownerTitle": "Head of Data" } picked from your job search – opens each job (st.openJob), reads the company with employees matching the owner title and its top decision makers, and writes one packet per job to packets.json. Failed reads are marked retry, never turned into "no owner found".

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",
});

interface JobLead {
  jobUrl: string;
  ownerTitle: string;
}

interface PersonRef {
  name: string;
  headline: string;
  url: string;
  degree: string | null;
}

interface JobPacket {
  jobUrl: string;
  status: "ok" | "partial" | "retry" | "unknownCompany";
  title?: string;
  postedDate?: string | null;
  applicantsCount?: number | null;
  company?: string;
  employeesCount?: number;
  jobsCount?: number;
  possibleOwners?: Array<PersonRef>;
  decisionMakers?: Array<PersonRef>;
  warm?: Array<PersonRef>;
  detail?: string;
}

function toPersonRef(person: {
  name: string;
  headline: string;
  publicUrl: string;
  viewerState: { connectionDegree: string | null };
}): PersonRef {
  const { name, headline, publicUrl, viewerState } = person;
  return { name, headline, url: publicUrl, degree: viewerState.connectionDegree };
}

async function buildPacket(lead: JobLead): Promise<JobPacket> {
  const { jobUrl, ownerTitle } = lead;
  try {
    const jobRun = await linkedapi.fetchJob.execute({ jobUrl });
    const { data: job, errors: jobErrors } = await linkedapi.fetchJob.result(jobRun.workflowId);
    if (!job) {
      const [error] = jobErrors;
      return { jobUrl, status: "retry", detail: error ? error.message : "no job data" };
    }
    const { title, postedDate, applicantsCount, companyUrl } = job;
    if (!companyUrl) {
      return { jobUrl, status: "unknownCompany", title, postedDate, applicantsCount };
    }

    const companyRun = await linkedapi.fetchCompany.execute({
      companyUrl,
      retrieveEmployees: true,
      employeesRetrievalConfig: { limit: 10, filter: { position: ownerTitle } },
      retrieveDMs: true,
      dmsRetrievalConfig: { limit: 5 },
    });
    const { data: company, errors } = await linkedapi.fetchCompany.result(companyRun.workflowId);
    if (!company) {
      const [error] = errors;
      return { jobUrl, status: "retry", title, detail: error ? error.message : "no company data" };
    }
    const { name, employeesCount, jobsCount, employees = [], dms = [] } = company;
    const possibleOwners = employees.map(toPersonRef);
    const decisionMakers = dms.map(toPersonRef);
    const warm = [...possibleOwners, ...decisionMakers].filter((person) => person.degree === "1st");
    const detail = errors.map(({ message }) => message).join("; ");
    return {
      jobUrl,
      status: detail ? "partial" : "ok",
      title,
      postedDate,
      applicantsCount,
      company: name,
      employeesCount,
      jobsCount,
      possibleOwners,
      decisionMakers,
      warm,
      detail,
    };
  } catch (caught) {
    if (caught instanceof LinkedApiError) {
      return { jobUrl, status: "retry", detail: caught.message };
    }
    throw caught;
  }
}

async function main(): Promise<void> {
  const leads: Array<JobLead> = JSON.parse(await readFile("jobs.json", "utf8"));
  const packets: Array<JobPacket> = [];
  for (const lead of leads) {
    packets.push(await buildPacket(lead));
  }
  await writeFile("packets.json", JSON.stringify(packets, null, 2));
  const toCheck = packets.filter((packet) => packet.status !== "ok").length;
  console.log(`${packets.length - toCheck} packets ready, ${toCheck} to check or retry`);
}

main();

import json
from pathlib import Path

from linkedapi import (
    FetchCompanyParams,
    FetchJobParams,
    LimitParams,
    LinkedApi,
    LinkedApiConfig,
    LinkedApiError,
    StCompanyEmployeesFilter,
    StCompanyEmployeesRetrievalConfig,
)

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


def person_ref(person) -> dict:
    degree = person.viewer_state.connection_degree if person.viewer_state else None
    return {"name": person.name, "headline": person.headline, "url": person.public_url, "degree": degree}


def build_packet(job_url: str, owner_title: str) -> dict:
    try:
        job_run = linkedapi.fetch_job.execute(FetchJobParams(job_url=job_url))
        job_result = linkedapi.fetch_job.result(job_run.workflow_id)
        job = job_result.data
        if job is None:
            detail = job_result.errors[0].message if job_result.errors else "no job data"
            return {"jobUrl": job_url, "status": "retry", "detail": detail}
        if not job.company_url:
            return {
                "jobUrl": job_url,
                "status": "unknownCompany",
                "title": job.title,
                "postedDate": job.posted_date,
                "applicantsCount": job.applicants_count,
            }

        company_run = linkedapi.fetch_company.execute(
            FetchCompanyParams(
                company_url=job.company_url,
                retrieve_employees=True,
                employees_retrieval_config=StCompanyEmployeesRetrievalConfig(
                    limit=10, filter=StCompanyEmployeesFilter(position=owner_title)
                ),
                retrieve_dms=True,
                dms_retrieval_config=LimitParams(limit=5),
            )
        )
        result = linkedapi.fetch_company.result(company_run.workflow_id)
        company = result.data
        if company is None:
            detail = result.errors[0].message if result.errors else "no company data"
            return {"jobUrl": job_url, "status": "retry", "title": job.title, "detail": detail}
        possible_owners = [person_ref(person) for person in company.employees or []]
        decision_makers = [person_ref(person) for person in company.dms or []]
        detail = "; ".join(error.message for error in result.errors)
        return {
            "jobUrl": job_url,
            "status": "partial" if detail else "ok",
            "title": job.title,
            "postedDate": job.posted_date,
            "applicantsCount": job.applicants_count,
            "company": company.name,
            "employeesCount": company.employees_count,
            "jobsCount": company.jobs_count,
            "possibleOwners": possible_owners,
            "decisionMakers": decision_makers,
            "warm": [person for person in possible_owners + decision_makers if person["degree"] == "1st"],
            "detail": detail,
        }
    except LinkedApiError as caught:
        return {"jobUrl": job_url, "status": "retry", "detail": caught.message}


leads = json.loads(Path("jobs.json").read_text())
packets = [build_packet(lead["jobUrl"], lead["ownerTitle"]) for lead in leads]
Path("packets.json").write_text(json.dumps(packets, indent=2, ensure_ascii=False))
to_check = sum(1 for packet in packets if packet["status"] != "ok")
print(f"{len(packets) - to_check} packets ready, {to_check} to check or retry")

Finding the jobs in the first place – searchJobs with the filters above, and polling for new postings – is covered with code in our LinkedIn jobs API guide. Approved notes and messages go out with sendConnectionRequest and sendMessage at a human pace, inside the per-account limits you set, and the inbox webhook tells your code when someone replies, so the follow-up is skipped.

How to measure recruitment business development

Count the funnel weekly, per niche:

Agency Leads' playbook names the two ratios that show where it breaks: "Meeting rate: percentage of conversations that convert to a discovery call" and "Close rate: percentage of discovery calls that result in a job order or signed contract". LinkedIn's own BD InMail report for RPS+ tracks "Sent, Responded, Accepted, Not responded, or Hours to accept" (Recruiter Help) – the same top of the funnel. There is no public benchmark worth borrowing, so treat your first month as the baseline and change one thing at a time: the niche, the signal, or the message.

Tools agencies use for business development

When a bundled tool is the better choice. If your team already works in LinkedIn Recruiter, RPS+ does BD inside the seat you pay for. If you want contact data, email sequences and the CRM in one product, an agency platform such as Loxo, Bullhorn or Recruiterflow is built for that. If your BD is mostly email at volume, a sequencing tool with verified contact data fits better than a LinkedIn layer. And if nobody on the team will own an agent's prompt and review its drafts, start with the manual routine above. Linked API fits when you want the LinkedIn research and sending on your own account, inside your own agent or code.

Keep your LinkedIn account in good standing

LinkedIn publishes no fixed number of invitations you may send, but it does say what triggers a restriction: "many invitations within a short amount of time", invitations "ignored, left pending, or marked as spam", and suspected use of an automation tool (LinkedIn Help). BD on LinkedIn works at low volume anyway: a few targeted touches a week, each about a specific role or change.

Linked API runs your account in a real, dedicated cloud browser – LinkedIn's own pages, at a human pace, inside the per-account limits you set – and never stores your password. Like any automation, it carries some risk, which is why the volume and the reason for each message matter more than the tool. The AI BDR guide covers the account questions to ask of any tool in more depth.

Frequently Asked Questions (FAQ)

Build it in, or hand it to an agent

Build the BD research and sending into your own 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 – reading each hiring company, drafting each touch 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 3, 2026 – LinkedIn Help pages, the LinkedIn × ASA report and the vendor pages named here checked on that date.