# Account-Based Selling on LinkedIn: Tiers, Plays and Measurement

Account-based sales on LinkedIn – tier target accounts, plan a play per tier, run a coordinated cadence and measure each account, with an AI agent or in code.

Account-based selling, also called account-based sales, turns prospecting around: instead of working a long list of people, you pick a few companies worth winning and sell to each one as a unit. This guide covers what that means, how it differs from account-based marketing, and how to run it on LinkedIn – tiers, plays, a coordinated cadence and account-level measurement – with an AI agent or code doing the research and drafts while you approve what is sent.

> **The short version.** Account-based selling – also called account-based sales – means choosing a small set of high-value companies and selling to each one as a market of one: researching the account, reaching several people in its buying group with messages about what each of them owns, and measuring progress per account rather than per email. Account-based marketing works the same accounts from the marketing side – on LinkedIn it often adds paid ads aimed at a list of companies – and this guide covers the sales-led outreach. On LinkedIn the work is: pick and tier your target accounts, find the right people and who you already know there, plan a play for each tier, run a coordinated cadence that starts with your warmest contact and adds people week by week, and review every account's progress weekly. An AI agent can keep each account's research current and draft every touch, as long as you approve what is sent.

## What is account-based selling?

Account-based selling is a B2B sales approach that treats each target company as a market of one: a defined list of accounts, several people reached at each, and progress judged by account. HubSpot puts it the same way – "An account-based model treats every account like a market of one."

| | Who runs it | Main channels | What it measures |
| --- | --- | --- | --- |
| Account-based selling (ABS) | Sales – AEs and SDRs | Outreach to named people at named accounts: LinkedIn, email, calls, meetings | Meetings and pipeline per account |
| Account-based marketing (ABM) | Marketing, working with sales | Content, events and ads for the same accounts – and, in [LinkedIn's own description](https://business.linkedin.com/advertise/resources/marketing-terms/abm), sales outreach and organic engagement too | Account engagement and pipeline |
| LinkedIn account-based advertising | Marketing | Paid ads to an uploaded company list – LinkedIn's [company targeting](https://business.linkedin.com/advertise/ads/targeting/company-targeting) takes up to 300,000 company names | Reach and engagement by account |

When both teams work the same accounts, they share one target list, one owner per account and one activity record, so a buyer does not get an ad, an SDR message and an AE invitation in the same week from people who do not know about each other. LinkedIn's ABM page makes the same point about collaboration tools that "allow sales teams to share insights, notes, and updates about target accounts".

You will also meet "target account selling" – an older, named sales methodology (TAS) sold by OnTarget, which Siebel acquired in 1999 and which later became The TAS Group ([InfoWorld](https://www.infoworld.com/article/2181466/oracle-to-sell-siebel-s-ontarget.html)). It shares the idea of focusing on a few accounts, but it is a specific branded process.

## When account-based selling is worth it

It fits deals that are large, few and slow, decided by many people. Forrester's survey of nearly 18,000 business buyers found that "13 internal stakeholders and nine external participants influence buying decisions" on average ([Forrester](https://www.forrester.com/blogs/state-of-business-buying-2026/)) – survey context for why one contact is rarely enough, not a list of 22 people to message.

Pace matters too. LinkedIn's B2B Institute puts it bluntly: "95% of your potential buyers aren't ready to buy today" ([LinkedIn B2B Institute](https://business.linkedin.com/advertise/resources/b2b-institute/b2b-research/trends/95-5-rule)). Its author, Professor John Dawes, says "The 95% figure is not meant to be a precise rule" and is used "as a heuristic to get the idea across" ([John Dawes](https://johndawes.info/the-955-rule/)). Our reading: plan in months per account, not in a two-week burst.

It is the wrong motion for high-volume, low-price sales, where a person-by-person process – such as [AI-assisted prospecting](/guides/ai-sales-prospecting-linkedin) – costs less per deal.

## Choose and tier your target accounts

Start with fit you can actually read: industry, company size, location, whether the company is hiring or growing, and what it posts about. [Company search](/docs/action-st-search-companies) and [company pages](/docs/action-st-open-company-page) give you all of that.

Then tier the list. This is one illustrative model – editorial guidance, not a benchmark:

| Tier | Active accounts per seller | People per account | Research depth | Personalization |
| --- | --- | --- | --- | --- |
| Tier 1 – one to one | 10–20 | 4–6 | A full account plan | Every message individual |
| Tier 2 – one to few | 30–50, in a few clusters | 2–3 | A short brief per cluster | One angle per cluster, a personal opening |
| Tier 3 – one to many | A watchlist of up to a few hundred, not actively worked | 1–2, once a trigger fires | A trigger note | A template plus one specific line |

Only tiers 1 and 2 count against a seller's capacity; tier 3 is a watchlist. Vendor guides draw the lines differently, and each figure has its own scope. HubSpot's first tier of 20 to 50 accounts is worked jointly by sales, sales development, marketing and executives, with about 200 accounts in a second tier. Salesmotion has each AE own 10–20 tier-1 accounts end to end, with 50–100 tier-2 accounts on warm nurture and 200–500 tier-3 accounts on automated engagement and signal monitoring. Expandi uses 5–25, 25–150 and "hundreds", and maps four to six people per tier-1 account.

Re-tier when something changes – a hiring push, a new leader, someone at the account engaging with your posts. Which of those signals LinkedIn shows you is covered in [LinkedIn buying signals](/guides/linkedin-buying-signals).

## Find the people – and who you already know there

Cover more roles at tier 1 than at tier 3 – typically the person who owns the problem, the one who owns the budget, and whoever has to evaluate or approve. Mapping the buying committee role by role is its own job, covered in [B2B buying committee](/guides/b2b-buying-committee).

The first move is not a cold invitation. It is the people you already know at the account – your 1st-degree connections there – and then anyone who could introduce you. Sales Navigator's TeamLink helps with the second: it "helps you find prospects who can be introduced to you through someone you know", on Advanced and Advanced Plus plans ([LinkedIn Help](https://www.linkedin.com/help/sales-navigator/answer/a101027)).

## Plan the play for each tier

A tier-1 play is an account plan. For an invented example – Northwind sells warehouse analytics to Fabrikam, an 870-person logistics company that just posted about delays in peak season:

| Person (role) | What they own | Angle | First touch | Follow-up |
| --- | --- | --- | --- | --- |
| Head of Customer Success – a 1st-degree connection | Customer retention | How late shipments show up in renewals | A message asking how decisions like this get made at Fabrikam | Thanks, plus one relevant example |
| VP Operations – the likely champion | Warehouse throughput | The peak-season post | A connection request with a note about that post | After acceptance, a two-line idea and a short-call ask |
| Director of Data – the evaluator | Integration and data quality | Fitting the existing data stack | A connection request in week 3, referencing their stack | A technical one-pager if they reply |
| CFO – the economic buyer | Cost and return | The cost of delays | Only after a conversation with the champion, ideally through them | – |

A tier-2 play reuses one angle across a cluster of similar accounts, with a personal opening for each person. A tier-3 play waits for a trigger – a hiring post, a new leader – and then sends one specific message.

## Run a coordinated cadence across the account

A starting schedule – editorial guidance, to test:

1. **Week 1** – your warmest contact: a 1st-degree connection or the likely champion. Engage genuinely with their posts.
2. **Week 2** – a second role, with a connection request and a note about what they own.
3. **Weeks 3–4** – the evaluator or the economic buyer. Mention an earlier conversation only if that person agreed you could.
4. **Then** – follow-ups on open threads, about a week apart.

Three rules keep it from turning into noise:

- **A cap of about two direct touches per account per week** – invitations and messages, across all its people. A genuine comment on a post does not count, and is never automated filler.
- **One owner per account**, so two colleagues never write to the same buyer in the same week.
- **A reply changes the plan.** That thread becomes a conversation, and new threads wait until you understand how the decision is made.

Salesmotion's version is similar: initial outreach to two or three stakeholders in weeks 1–2, a third at a different level in weeks 3–4, and the economic buyer in weeks 5–8. For the note itself, see [connection request message examples](/guides/linkedin-connection-request-message); for choosing between a message and an invitation, see [connection degrees](/guides/linkedin-connection-degrees).

## Measure accounts, not activities

Messages sent says little in account-based selling. Track each account on one line and review the board weekly:

| Account | Tier | People planned / reached | Your 1st-degree connections there | Engaged (accepted or replied) | Meeting | Opportunity | Last touch | Next step |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Fabrikam | 1 | 4 / 2 | 1 | 2 | Booked | Discovery | Oct 30 | Evaluator invitation, week 3 |

Re-tier quarterly. The account-level measures the main guides name – account engagement, stakeholder coverage, deal velocity – all come down to this table filled in honestly.

## Run it with an AI agent – or in code

The research is what keeps the board current, and it is the part to automate. The script reads `accounts.json` – company page URLs with their tier – and writes `account-summaries.json`: each company's size and open jobs, your 1st-degree connections there, the five most senior decision makers LinkedIn lists, and the company's posts from the last 30 days.

```typescript
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() - 30 * 24 * 60 * 60 * 1000).toISOString().replace(/\.\d{3}Z$/, "Z");

interface TargetAccount {
  companyUrl: string;
  tier: 1 | 2 | 3;
}

interface PersonRef {
  name: string;
  headline: string;
  url: string;
}

interface AccountSummary {
  companyUrl: string;
  tier: number;
  status: "complete" | "partial" | "retry";
  name?: string;
  employeesCount?: number;
  openJobs?: number;
  yourConnections?: Array<PersonRef>;
  seniorDecisionMakers?: Array<PersonRef>;
  recentPosts?: Array<{ time: string; url: string; text: string }>;
  detail?: string;
}

function toPersonRef(person: { name: string; headline: string; publicUrl: string }): PersonRef {
  const { name, headline, publicUrl } = person;
  return { name, headline, url: publicUrl };
}

async function summarize(account: TargetAccount): Promise<AccountSummary> {
  const { companyUrl, tier } = account;
  try {
    const workflow = await linkedapi.fetchCompany.execute({
      companyUrl,
      retrieveEmployees: true,
      employeesRetrievalConfig: { limit: 50, filter: { connectionDegrees: ["1st"] } },
      retrieveDMs: true,
      dmsRetrievalConfig: { limit: 5 },
      retrievePosts: true,
      postsRetrievalConfig: { limit: 5, since: POSTS_SINCE },
    });
    const { data, errors } = await linkedapi.fetchCompany.result(workflow.workflowId);
    if (!data) {
      const [error] = errors;
      return { companyUrl, tier, status: "retry", detail: error ? error.message : "no company data" };
    }
    const { name, employeesCount, jobsCount, employees = [], dms = [], posts = [] } = data;
    const detail = errors.map(({ message }) => message).join("; ");
    return {
      companyUrl,
      tier,
      status: detail ? "partial" : "complete",
      name,
      employeesCount,
      openJobs: jobsCount,
      yourConnections: employees.map(toPersonRef),
      seniorDecisionMakers: dms.map(toPersonRef),
      recentPosts: posts
        .filter((post) => post.text)
        .map(({ time, url, text }) => ({ time, url, text: text ?? "" })),
      detail,
    };
  } catch (caught) {
    if (caught instanceof LinkedApiError) {
      return { companyUrl, tier, status: "retry", detail: caught.message };
    }
    throw caught;
  }
}

async function main(): Promise<void> {
  const accounts: Array<TargetAccount> = JSON.parse(await readFile("accounts.json", "utf8"));
  const summaries: Array<AccountSummary> = [];
  for (const account of [...accounts].sort((a, b) => a.tier - b.tier)) {
    summaries.push(await summarize(account));
  }
  await writeFile("account-summaries.json", JSON.stringify(summaries, null, 2));
  const toCheck = summaries.filter((summary) => summary.status !== "complete").length;
  console.log(`${summaries.length - toCheck} accounts summarized, ${toCheck} to check or retry`);
}

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

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

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

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

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


def person_ref(person) -> dict:
    return {"name": person.name, "headline": person.headline, "url": person.public_url}


def summarize(company_url: str, tier: int) -> dict:
    try:
        workflow = linkedapi.fetch_company.execute(
            FetchCompanyParams(
                company_url=company_url,
                retrieve_employees=True,
                employees_retrieval_config=StCompanyEmployeesRetrievalConfig(
                    limit=50, filter=StCompanyEmployeesFilter(connection_degrees=["1st"])
                ),
                retrieve_dms=True,
                dms_retrieval_config=LimitParams(limit=5),
                retrieve_posts=True,
                posts_retrieval_config=LimitSinceParams(limit=5, since=POSTS_SINCE),
            )
        )
        result = linkedapi.fetch_company.result(workflow.workflow_id)
        company = result.data
        if company is None:
            detail = result.errors[0].message if result.errors else "no company data"
            return {"companyUrl": company_url, "tier": tier, "status": "retry", "detail": detail}
        detail = "; ".join(error.message for error in result.errors)
        return {
            "companyUrl": company_url,
            "tier": tier,
            "status": "partial" if detail else "complete",
            "name": company.name,
            "employeesCount": company.employees_count,
            "openJobs": company.jobs_count,
            "yourConnections": [person_ref(person) for person in company.employees or []],
            "seniorDecisionMakers": [person_ref(person) for person in company.dms or []],
            "recentPosts": [
                {"time": post.time, "url": post.url, "text": post.text}
                for post in company.posts or []
                if post.text
            ],
            "detail": detail,
        }
    except LinkedApiError as caught:
        return {"companyUrl": company_url, "tier": tier, "status": "retry", "detail": caught.message}


accounts = json.loads(Path("accounts.json").read_text())
summaries = [summarize(account["companyUrl"], account["tier"]) for account in sorted(accounts, key=lambda account: account["tier"])]
Path("account-summaries.json").write_text(json.dumps(summaries, indent=2, ensure_ascii=False))
to_check = sum(1 for summary in summaries if summary["status"] != "complete")
print(f"{len(summaries) - to_check} accounts summarized, {to_check} to check or retry")
```

What the summary gives you:

- **`yourConnections`** – up to 50 of your 1st-degree connections at the account, the warm starting points.
- **`seniorDecisionMakers`** – LinkedIn returns decision makers ranked by seniority, founders and C-level first ([docs](/docs/action-st-retrieve-company-dms)); the script keeps the top five.
- **`partial`** means the company page came back but part of it did not, so an empty list is not mistaken for "nobody there"; **`retry`** covers a page that could not be read and a request that failed.

An AI agent can run the weekly review from a plain-language ask through the [MCP server](/mcp/available-tools), the [CLI](/cli/getting-started) or a ready-made [skill](/skills). An illustrative prompt:

> Every Monday: read accounts.json, last week's account summaries and my activity log. For each tier-1 and tier-2 account, fetch the company page and list what changed since last week – new posts, open jobs, new 1st-degree connections, new decision makers. If there is no previous summary for an account, write a baseline instead and say so. Propose the next touch for each planned role, with a draft, within two invitations or messages per account per week. Send nothing until I approve each draft.

The agent reads with `fetch_company` and sends only what you approve with `send_connection_request` or `send_message`; the approval gate lives in your instructions or your code. Each request runs in your account's dedicated cloud browser at a human pace, within the per-account limits you set ([admin limits](/docs/admin-limits)). [Inbox monitoring](/docs/monitoring-inbox) reports replies and [network monitoring](/docs/monitoring-network) reports accepted invitations, so the board updates itself. More on what an agent can do on your account is in [LinkedIn AI agents](/guides/linkedin-ai-agent).

## Which tool does which part

Account-based selling usually runs on several tools. What each one documents on its own pages:

| Tool | What it is for | What its pages say |
| --- | --- | --- |
| LinkedIn Sales Navigator | Account lists and research inside LinkedIn | Account lists from CSV on Advanced and Advanced Plus, up to 1,000 accounts ([LinkedIn Help](https://www.linkedin.com/help/sales-navigator/answer/a1378574)); Relationship Explorer "surfaces up to eight of the most relevant leads at an account"; Buyer Intent and TeamLink on Advanced and Advanced Plus |
| 6sense | Intent data and ads | "6sense identifies the account behind anonymous research, not the individual" |
| Demandbase | ABM platform – intent, buying groups, ads | "Your AI agent builds your buying groups in seconds", from a "150 million+ contact database" |
| Clay | Enrichment and research workflows | "200+ data and AI vendors" in its marketplace, Claygent research agents, waterfall enrichment and an email sequencer |
| Common Room | Person-level signals | "Every buyer. Person-level. No gaps."; sequences that "advance automatically when a prospect goes quiet" |
| Salesmotion | Account research and drafts | Signal, research and outreach agents; reps "Review, refine, and send" the drafts |
| Apollo | Contact database and sequences | LinkedIn steps run as tasks in the rep's queue |
| Linked API | The LinkedIn execution layer on your own account | Company and people research, invitations and messages from your code or your agent, sent only when you approve; no ads, email or third-party intent, so it works alongside the tools above |

If your team already has Sales Navigator Advanced seats, its account lists, Relationship Explorer and TeamLink do much of the research by hand – see [what each Sales Navigator plan costs](/guides/linkedin-sales-navigator-cost).

## Frequently Asked Questions (FAQ)

#### What is account-based selling?

A B2B sales approach that treats each target company as a market of one: a short list of high-value accounts, several people reached at each with messages about what they own, and progress measured per account. It is also called account-based sales.

#### What is the difference between account-based selling and account-based marketing?

Account-based selling is led by sales and measured in meetings and pipeline per account. Account-based marketing is led by marketing and works the same accounts with content, events and ads – and in LinkedIn's description, sales outreach too. When both run, they should share one target list, one owner per account and one activity record.

#### What are target accounts?

The specific companies a team has decided to win, chosen for fit – industry, size, location, growth and need – and usually grouped into tiers by how much attention each gets.

#### How many target accounts should a rep have?

Fewer than most expect for one-to-one work. In our illustrative model a seller actively works 10–20 tier-1 and 30–50 tier-2 accounts, with a watchlist on top. Vendor guides vary: Salesmotion has each AE own 10–20 tier-1 accounts, while HubSpot's 20–50-account tier is worked jointly by sales, SDRs, marketing and executives.

#### Which metrics matter in account-based sales?

Per account: people planned versus reached, how many engaged, meetings, opportunity stage and the date of the last touch. Account engagement, stakeholder coverage and deal velocity are summaries of those.

#### Can AI run account-based selling?

It can do the research, keep each account's summary current, draft every touch and report what changed. A seller should approve each message before it is sent, and own the relationships.

## Build it in, or hand it to an agent

Build account research, drafts and the account board into your CRM or sales tool with the REST API, the [Node and Python SDKs](/sdks/installation) or the shell [CLI](/cli/getting-started). Or have an AI agent run it out of the box through the [MCP server](/mcp/overview), the agent-friendly CLI or a ready-made [skill](/skills) – reading each account, 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](/pricing).

*Facts verified November 2, 2026 – LinkedIn Help pages, the Forrester, LinkedIn B2B Institute and John Dawes sources, and the vendor pages named here checked on that date.*