# LinkedIn Sales Navigator Scraper (Leads & Accounts) (`rayackery/linkedin-sales-navigator-scraper`) Actor DEEP profile information faster than any other scraper! Turn LinkedIn Sales Navigator lead and account searches into clean, flat rows: names, titles, companies, locations and profile links, with optional full profile or company details. - **URL**: https://apify.com/rayackery/linkedin-sales-navigator-scraper.md - **Developed by:** [Denys Petrenko](https://apify.com/rayackery) (community) - **Stats:** 2 total users, 2 monthly users, 83.3% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.00 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### What it does Turn your LinkedIn Sales Navigator searches into clean, flat data. Give the Actor one or more search links and your own Sales Navigator session, and it saves one row per lead or per company: name, job title, company, location and links to the LinkedIn and Sales Navigator pages. It's built for sales, recruiting and research teams that already have a Sales Navigator seat and want their searches in a spreadsheet, a CRM or an automation. - Works with lead searches and account (company) searches, saved searches, recent searches and lists. You can mix them in one run. - Big search links are split automatically. A search link is the address of a lead or account search with your filters, copied from the address bar. When it holds more than a single search can page (2,500 leads, about 1,670 companies), the Actor splits it into smaller searches and saves all of them into the same dataset: lead searches by location, function and seniority, account searches by industry and then headquarters country. You get far more than a single search would give, though a big account search can still leave many companies out (see Limits). Saved searches, recent searches and lists aren't split. - Every row has readable field names such as `firstName`, `jobTitle` and `company`. There's no nested JSON, so the data opens cleanly in Excel and Google Sheets. - **Deep** mode adds each lead's full profile (headline, full position history, education, skills, languages, connection counts, last activity, and the contact details LinkedIn shows you) or each company's details (type, founding year, revenue range, headcount growth, headquarters, website). - A result that appears under two of your links is saved once. - Rows are saved as they're found, so a run that stops early keeps everything it already saved. > **This Actor uses your own LinkedIn account.** It signs in to Sales Navigator with the session you paste in, so every request counts as yours. LinkedIn's User Agreement prohibits automated access, and heavy use can get your account restricted. Keep your volumes moderate and read the Limits section before your first run. This Actor is not affiliated with or endorsed by LinkedIn. ### How to run it 1. Click **Try for free** (or **Start** if you've used the Actor before). 2. In **Sales Navigator links**, paste the address of each search or list, one per line. Run the search in Sales Navigator first and copy the address bar once the results have loaded. 3. In **LinkedIn session (Copy as cURL)**, paste your session. [How to copy your session](#how-to-copy-your-session) takes about a minute. 4. Choose fast (the default) or turn on **Deep**, and set **Max results, in total**. For a first run, keep the default of 100. 5. Under **Proxy**, keep the residential proxy and pick the country you normally log in to LinkedIn from. 6. Optional but recommended: set a **maximum cost** for the run in the run options. The run stops itself before it goes over (see [Pricing](#pricing)). 7. Click **Start**. The status line shows progress, for example `Link 1 of 3: 250 of 1,234 leads saved`. 8. When the run finishes, open the **Output** tab and download the rows as CSV, Excel or JSON. To reuse the same links and settings, save them as a **task** and start the task whenever you need fresh data. #### On a schedule Attach a task to an Apify **schedule** to run it daily or weekly. Each scheduled run starts from the first result of each link and is charged like any other run, so point scheduled tasks at searches that only return what's new to you, for example with Sales Navigator's filters for recent job changes. When LinkedIn ends your session, scheduled runs fail with a message saying so: copy a fresh session into the task. #### Through the API The **API** tab on this page shows ready-made calls for your account, in several languages. The input is the same JSON as the form: ```json { "searchUrls": ["https://www.linkedin.com/sales/search/people?savedSearchId=1234567890"], "browserRequest": "curl 'https://www.linkedin.com/sales-api/salesApiLeadSearch?...' -H '...' ...", "deepProfile": false, "maxResults": 100, "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" } } ``` Add `maxTotalChargeUsd` to the run call to cap what the run can cost. The session field is stored encrypted, also when you pass it through the API. #### With your other tools Apify's integrations start runs from n8n, Make or Zapier, and send the results to Slack, a webhook or your own workflow when a run finishes. Set them up on the **Integrations** tab of this Actor or of your saved task. ### How to copy your session The Actor needs one real Sales Navigator request from your browser. It holds your login, so treat it like a password. The field is stored encrypted. 1. Open your search in Sales Navigator in Chrome. 2. Open DevTools (⌥⌘I on Mac, Ctrl+Shift+I on Windows), open the **Network** tab and type `salesApi` into its filter box. 3. Reload the page, right-click a `salesApiLeadSearch` row (or `salesApiAccountSearch` for company searches), and choose **Copy → Copy as cURL (bash)**. 4. Paste it into the **LinkedIn session (Copy as cURL)** field. Choose **Copy as cURL (bash)**, not the cmd or PowerShell versions. What you paste should start with `curl '`. A cookie export, a file path or a link won't work. A session lasts until LinkedIn ends it. If a run says the session ended, log in to Sales Navigator in Chrome again and copy a fresh request. ### Input | Field | What it does | Default | |---|---|---| | **Sales Navigator links** (required) | One link per search, copied from the address bar of a Sales Navigator lead or account search. Saved searches, recent searches and lists work too. Lead and account links can be mixed. | none | | **LinkedIn session (Copy as cURL)** (required) | The request you copied in the steps above. | none | | **Deep: full profiles or company details** | Also fetch each lead's full profile or each account's company details. Slower, and it adds a charge for each row that gets the extra details. | off | | **Max results, in total** | Stop after this many rows, counted across all your links. Use 0 for no limit. It also decides whether a big search link is split: only when this is 0, or more than one search can page (2,500 leads, about 1,670 companies). | 100 | | **Proxy** | Residential proxies are used by default. Choose your own country so the run looks like it comes from where you normally log in to LinkedIn. | Apify residential proxy | | **Pause between batches** (Advanced) | Seconds to wait between batches of deep lookups, at least 1. The real wait is random, between this and twice this. Only used when Deep is on. Raise it if LinkedIn starts slowing you down. | 3 | | **Add every raw LinkedIn field** (Advanced) | Adds a `raw` field to each row with everything LinkedIn returned. Makes the dataset much larger. | off | ### Pricing You pay per event. The exact prices are on this Actor's **Pricing** tab. There may also be a small start fee, charged once when a run starts; if there is one, the Pricing tab shows it. | Event | When you're charged | |---|---| | Result (`result`) | Once for every lead or account saved to your dataset. | | Deep details (`deep-details`) | Once more for each result that also got its full profile or company details. Only when Deep is on and LinkedIn returned the details. If LinkedIn refused the details for a result, that row is saved with the reason and you pay only the result charge. | With Deep off, 1,000 rows are 1,000 result events. With Deep on and every detail fetched, they're 1,000 result events plus 1,000 deep details events. Counting and splitting requests aren't charged. When a big search link is split, you pay only for the rows that get saved. **Maximum cost.** Set a maximum cost for the run before you start it. The Actor works out how many results that pays for and stops itself there, with `Stopped at your spending limit: N results saved.` Everything saved up to that point is kept. If the limit can't pay for a single result, the run fails straight away, before it contacts LinkedIn. The run also stops at **Max results, in total**, whichever comes first. A run that fails because a link or the session can't be used saves no rows, so no result is charged. A start fee, if the Pricing tab shows one, still applies. **A new run charges again.** Every run starts at the first result of each link and charges for every row it saves, including rows an earlier run already saved. It doesn't look at your earlier runs. To avoid paying twice, make a new run's links cover only what's still missing, using extra filters in Sales Navigator such as a location, an industry or a company size (see the FAQ on getting more than 2,500 results from one search). To merge datasets from different runs and remove duplicates, match on `linkedinMemberId` for leads and `linkedinCompanyId` for accounts; they stay the same for the same person or company in every run. If a lead's `linkedinMemberId` is empty, match on its `salesNavigatorUrl` instead. ### Output Results go to the run's dataset. On the **Output** tab, the **Leads** and **Accounts** views show them as tables. Both views list every row of the run (Apify views can't filter rows), so they differ only in their columns: in a run that mixes lead and account links, filter on `type` after you download. You can download the rows as CSV, Excel or JSON, or read them through the API. Every row has: - `id`: identifies the row within this run. It includes a token from the search, so the same lead can have a different `id` in another run. - `type`: `lead` or `account`. - The columns for that kind, with plain-English names. In a run that mixes lead and account links, each row has only the columns of its own kind. - `raw`: only if you turn on **Add every raw LinkedIn field**. Example rows (made-up data, shortened by leaving out `searchUrl`, the link the row came from). A lead, fast mode: ```json { "id": "urn:li:fs_salesProfile:(ACwAAA00000001xyz,NAME_SEARCH,t001)", "type": "lead", "firstName": "Jane", "lastName": "Example1", "fullName": "Jane Example1", "jobTitle": "Head of Sales", "company": "Acme Robotics", "timeInRole": "1 yr 2 mos", "timeAtCompany": "3 yrs", "location": "Berlin, Germany", "linkedinUrl": "https://www.linkedin.com/in/ACwAAA00000001xyz", "salesNavigatorUrl": "https://www.linkedin.com/sales/lead/ACwAAA00000001xyz", "companyLinkedinUrl": "https://www.linkedin.com/company/4242", "connectionDegree": 2, "premium": false, "savedLead": false, "spotlights": "Recently hired", "about": "Builds robots.", "previousPositions": "AE @ Old Co", "linkedinMemberId": "100001", "fetchedDate": "2026-10-21" } ``` An account, fast mode: ```json { "id": "urn:li:fs_salesCompany:9001", "type": "account", "companyName": "Widget Works 1", "industry": "Computer Hardware Manufacturing", "employees": 119, "headcountRange": "51-200", "linkedinUrl": "https://www.linkedin.com/company/9001", "salesNavigatorUrl": "https://www.linkedin.com/sales/company/9001", "description": "We make widgets.", "saved": true, "lists": 1, "spotlights": "", "linkedinCompanyId": "9001", "fetchedDate": "2026-10-21" } ``` **What Deep adds.** - Leads: `headline`, `email`, `otherEmails`, `phone`, `websites`, `connections`, `sharedConnections`, `openProfile`, `education`, `skills`, `languages`, `lastActivity` and `deepProfileError`. `linkedinUrl` becomes the public `/in/name` link. Email and phone are only filled for people whose contact details LinkedIn shows you, usually your 1st-degree connections. - Accounts: `companyType`, `founded`, `revenueRange`, `headcountGrowth6MonthsPct`, `headcountGrowth1YearPct`, `headcountGrowth2YearsPct`, `fundingEvents`, `location`, `hqStreet`, `hqCity`, `hqStateRegion`, `hqPostalCode`, `hqCountry`, `website`, `starred`, `notes` and `deepProfileError`. If LinkedIn refuses the details for one result, the row is still saved, and `deepProfileError` says why. ### Limits - **Saved searches, recent searches and lists still stop at LinkedIn's paging limit.** Sales Navigator pages through at most 2,500 results for a lead search and about 1,670 for an account search. Search links you paste from a lead or account search are split automatically, but these three aren't. To get more from one of them, split it with extra filters, for example by region or company size, and add each part as its own link. - **LinkedIn can stop paging earlier.** Sometimes LinkedIn stops serving a search before it reaches that limit. The run keeps what it has, and the run's final status message says where it stopped, for example `LinkedIn stopped paging … at result 1200 of 1800; split it with extra filters to get the rest.` - **A split link can still leave results out.** Lead search links are split by location, then function, then seniority. Account search links are split by industry, then headquarters country, and no further. LinkedIn's counts aren't exact, and one of the smaller searches can still hold more than LinkedIn pages. Most lead searches lose only a handful of people that way, but an account search can lose many companies: one industry in one country with more than about 1,650 companies still stops at LinkedIn's paging limit, and the run's final status message reports the rest as `search cap`. A very broad lead search can do the same when one location, function and seniority together hold more than 2,500 people. For each split link, the run's final status message says how many were found of how many, and how many couldn't be reached and why. For example: `Lead search: CFO: found 9,000 of 9,070; 70 couldn't be reached (count drift, search cap).` The reasons it can give: - `search cap`: one smaller search still holds more than LinkedIn will page, and the Actor can't narrow it further, so the rest of it is out of reach. For an account search, that's one industry in one country. - `count drift`: LinkedIn counted these people for your search, but none of the smaller searches listed them. LinkedIn's counts can also shift while a run is going. - `leaky split`: LinkedIn lists a few people under none of the functions or seniority levels the Actor splits a lead search by, so they fall between the smaller searches. `leaky split (upper bound)` means the same for a very big search, where the number is the most that could be missing. - `short after re-page`: a smaller search returned fewer people than LinkedIn counted for it, even when the Actor paged it a second time. - `filters dropped by LinkedIn`: LinkedIn ignored one of your filters and widened the search, so the Actor stopped that part instead of saving the wrong people. To try for the people or companies who couldn't be reached, run a narrower search link: add a filter such as a location, an industry or, for companies, a company size. A new run charges for every row it saves, including rows an earlier run already saved (see Pricing). - **Your maximum cost.** The run caps itself at what your maximum cost can pay for, as described under Pricing. - **One IP per run.** The Actor uses one residential IP for the whole run. Apify keeps an IP for about 30 minutes, so a longer run changes IP partway through, which LinkedIn may notice. A big search link that's split automatically can run for hours. To keep runs short instead, split the job yourself: run narrower links, for example one region each, in separate runs. - **Rate limits end the run.** If LinkedIn slows the session down, the Actor retries up to four times, waiting from 15 seconds up to 2 minutes. If that doesn't help, it stops and keeps what it saved. You can start a new run later; it starts over (see Pricing). - **Deep is slower.** It makes about one extra request for every 25 results. - **One run at a time per LinkedIn login.** Parallel runs on one login are a quick way to get logged out. **Your LinkedIn account.** The Actor uses your own LinkedIn account and your own session. LinkedIn's User Agreement prohibits automated access, and heavy use can get your account restricted or logged out. The Actor can't prevent that. Keep volumes moderate, prefer small batches over large ones, don't lower the pause between batches, and use a proxy in the country you normally log in from. Splitting a big search link adds counting requests on your session on top of the pages it saves, so a split link uses your session more than its rows alone suggest. You're responsible for how you use your account. ### FAQ #### The run says LinkedIn ended the session. What now? LinkedIn logged your session out, so it won't accept more requests. The run's final status message says: `LinkedIn ended the session after N results. Log in to Sales Navigator in Chrome, copy a fresh request (Copy as cURL) and run again.` Log in again, check LinkedIn for any security notice, wait a while, then copy a fresh request and start a new run (or update the session in your task). #### My run stopped early. Why? The run's final status message always says why. A run that saved at least one result ends as Succeeded, even if it stopped early; a run that saved nothing ends as Failed. If you stop a run yourself, Apify marks it Aborted. - `Stopped at your spending limit: N results saved.` Your maximum cost was reached. - `LinkedIn is rate-limiting this session; N results saved. Run again later.` LinkedIn is slowing your session down. Wait a few hours before the next run, and use smaller links. - `LinkedIn or the connection failed; N results saved. Run again later.` The connection kept failing after the retries. - `LinkedIn stopped paging … at result X of Y; split it with extra filters to get the rest.` See the next question. - `Skipped …: …` LinkedIn refused one of your links, for example a saved search that was deleted. The other links still ran. - `Aborted: N results saved.` You stopped the run. Results saved so far stay saved and charged. - `Stopped by an unexpected error; N results saved. Run again later.` Something unexpected went wrong, for example LinkedIn changed the shape of its answers. The run log has the details. If it keeps happening, report it on the **Issues** tab. - `Your spending limit doesn't cover a single result. Raise the run's maximum charge and try again.` The run failed without contacting LinkedIn. Before you start a new run to get the rest, remember that it starts over: it charges for every row it saves, including rows an earlier run already saved. Narrow its links to what's still missing. To merge the datasets afterwards, match on `linkedinMemberId` for leads and `linkedinCompanyId` for accounts, or on `salesNavigatorUrl` for a lead whose `linkedinMemberId` is empty. #### How do I get more than 2,500 results from one search? Search links, the addresses of lead or account searches with your filters copied from the address bar, are split automatically. When a link holds more than one search can page (2,500 leads, about 1,670 companies), the Actor splits it into smaller searches (by location, function and seniority for leads, by industry and then headquarters country for accounts) and saves all of them into one dataset. A result that appears in two of them is saved once. A link is only split when **Max results, in total** is higher than one search can page, so with the default of 100 nothing is split: set it to the number you want, or to 0 for no limit. Counting and splitting requests aren't charged. When the run ends, the run's final status message says how many were found of how many, and how many couldn't be reached and why. An account search can still leave many companies out: one industry in one country with more than about 1,650 companies stops at LinkedIn's paging limit (see Limits). Saved searches, recent searches and lists aren't split. Saved searches and lists can still be split manually with filters in Sales Navigator, such as region, industry or company size, and so can a recent search: add each part as its own link in **Sales Navigator links**. All links go into one dataset. The same works when LinkedIn stops paging a search early. #### The run failed straight away with a message about my link or session. What's wrong? The Actor checks your input before it contacts LinkedIn, so a run that fails here saves and charges no results. The message says what to fix: - `Add at least one Sales Navigator link.` The links field is empty. - `Link N isn't a Sales Navigator link.` Link number N isn't a Sales Navigator search or list. Run the search in Sales Navigator and copy the address bar once the results have loaded. - `Paste your LinkedIn session (Copy as cURL) first.` The session field is empty. - `Paste the request copied with Copy as cURL (bash); it starts with curl '…` You pasted something else, such as a cookie export, a file path or a link. - `Paste a fresh Copy as cURL (bash) from Chrome: …` The request couldn't be used. The rest of the message says why: it may be the Windows format (use the bash version), cut off, missing your login, or from a session LinkedIn has already ended. Copy a new one. #### What happens if Apify restarts my run? The run carries on where it stopped. Rows already saved aren't saved or charged again. This applies only to the same run; a new run you start yourself starts over (see Pricing). #### Does this collect personal data? Yes. The results are names, jobs and profile details of real people. You're responsible for using them in line with LinkedIn's terms and the privacy laws that apply to you. # Actor input Schema ## `searchUrls` (type: `array`): One link per search, copied from the address bar of a Sales Navigator lead or account search. Lead and account links can be mixed. A result that shows up under two links is saved once. ## `browserRequest` (type: `string`): Copy your session from Chrome:
1. Open your search in Sales Navigator in Chrome.
2. Open DevTools (⌥⌘I on Mac, Ctrl+Shift+I on Windows), open the Network tab and filter salesApi.
3. Reload, right-click a salesApiLeadSearch row (or salesApiAccountSearch for company searches), and choose Copy → Copy as cURL (bash).
4. Paste the result here. It holds your login; it's stored encrypted. ## `deepProfile` (type: `boolean`): Also fetch the full profile of each lead (headline, full position history, education, skills, languages, contact details and more) or the company details of each account. Slower, and it adds a charge for each row that gets the extra details. ## `maxResults` (type: `integer`): Stop after this many rows, counted across all your links. Use 0 for no limit. ## `proxy` (type: `object`): Residential proxies are used by default. Choose your own country so the run looks like it comes from where you normally log in to LinkedIn. ## `pauseSeconds` (type: `integer`): Seconds to wait between batches of deep lookups. The real wait is random, between this and twice this. Only used when Deep is on. Raise it if LinkedIn starts slowing you down. ## `includeRawFields` (type: `boolean`): Add a raw field to each row with everything LinkedIn returned. Makes the dataset much larger. ## Actor input object example ```json { "deepProfile": false, "maxResults": 100, "proxy": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] }, "pauseSeconds": 3, "includeRawFields": false } ``` # Actor output Schema ## `results` (type: `string`): All rows of the run: leads and accounts, with the Leads and Accounts table views. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "proxy": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("rayackery/linkedin-sales-navigator-scraper").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "proxy": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], } } # Run the Actor and wait for it to finish run = client.actor("rayackery/linkedin-sales-navigator-scraper").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 '{ "proxy": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call rayackery/linkedin-sales-navigator-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,rayackery/linkedin-sales-navigator-scraper" } } } ``` 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 ` 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/fKebizQS81r3hzYc1/builds/vQI0vCHvMsERACd42/openapi.json