Linkedin Jobs Scraper

Scrape LinkedIn job listings at scale. No API key. No login. No browser. No cookies. Pure HTTP — fast, cheap, and reliable. Built for AI agents, lead generation pipelines, and job market research.

---

What it does

This actor scrapes job listings from LinkedIn's public job search pages and returns clean, structured JSON. Give it keywords and a location, a batch of both, or just paste the search URL off linkedin.com. A country-wide search can be split into per-city searches to get past LinkedIn's 1,000-result ceiling.

Key data extracted:

• Job title, company, location, posted date, salary
• Full job description (plain text + HTML)
• Seniority level, employment type, job function, industries
• Applicant count
• Company size (employee count) and industry, when LinkedIn shows them

---

What's new

🔗 Paste a LinkedIn search URL

Build the search on linkedin.com the way you normally would, copy the address bar, drop it into searchUrls. Keywords, location, geo ID, radius and date range are read straight out of it — nothing to retype.

Paste several and each becomes its own search, keeping its own city and radius, so one run can cover Boise at 5 miles and Denver at 100. If the URL carries filters LinkedIn discards for logged-out clients (f_WT, f_E, f_JT), the run log names each one instead of letting you assume it applied.

🏙️ Split a country into cities — past the 1,000 cap

LinkedIn returns at most 1,000 results for any one search, so a country-wide query cannot go deeper however many jobs exist. Set splitByCity: true and a country becomes one search per major city.

This is worth the extra searches because cities return genuinely different jobs, not the same ones relabelled. Measured on registered nurse, serially, with no blocked responses:

	unique jobs	absent from a 500-job US walk
New York	150	145 (97%)
Houston	150	146 (97%)
Phoenix	150	148 (99%)

Those three cities shared nothing at all with one another, and together took reachable inventory from 500 to 939. Ten cities scale roughly the same way.

Supported: United States (30 cities), United Kingdom (12), Canada (10), Australia (8), Germany (8), India (8). maxCities controls how many are used, largest markets first. A location that is already a city, or a country not on that list, is searched exactly as you typed it.

📏 Radius, in miles

distance narrows or widens the search around your location — a real filter, verified before shipping rather than assumed. Around Boise, distance: 5 returns only Boise postings while distance: 100 also returns Caldwell, Gooding, Hailey, McCall and Meridian. An identical request run twice returns an identical set, so that difference is the filter working, not result churn.

🛡️ A throttled run now says it was throttled

When an offset genuinely has no results, LinkedIn answers with a 26-byte stub. When it is rate-limiting you, it answers with a full page carrying no listings. Earlier versions treated both as "no more results", stopped early, and still reported success — so a truncated run was indistinguishable from a complete one.

Such a page is now retried once. If it stays empty the run says the results may be incomplete, rather than implying that was everything LinkedIn had.

⚡ Faster runs — parallel pagination

Search pages are now fetched in concurrent batches instead of one at a time, cutting page-walk time up to ~4x on large or heavily-filtered searches. Same results, same order, same low cost — just faster. Smart early-stop still kicks in the moment a search is exhausted, so you never pay for pages you don't need.

🎯 Title-only filtering

Set titleOnly: true to keep only jobs whose title contains your keyword — perfect for precise role targeting (e.g. only actual "Product Analyst" titles, not every job that mentions "product" in the description). See the note in Input reference on using plain terms vs. Boolean syntax.

Batch Search

Run multiple keywords and locations in a single actor run. Use keywordsList and locationsList — the actor runs all combinations automatically and deduplicates results.

Example: ['python developer', 'data engineer'] × ['New York', 'Remote'] = 4 searches, one run.

Full Job Details

Enable fetchJobDetails to load each job's detail page and extract the full description (text + HTML), seniority level, employment type, job function, industry, applicant count, and salary when LinkedIn shows it.

Company Filter

Only want jobs from specific companies? Pass a list of company names or LinkedIn slugs and the actor filters automatically — no post-processing needed.

Description HTML

Both plain text and raw HTML of the job description are now included in the output — useful for agents that need to parse or render the content.

---

Use cases

Lead Generation

Turn LinkedIn hiring activity into a prospect pipeline:

• Find companies actively hiring in your target space
• Use company employee count and industry to qualify leads
• Feed into Clay, HubSpot, or Salesforce via Apify integrations

AI Agent Integration (MCP)

Use this actor as a live data source for AI agents:

• Search LinkedIn jobs in real time from Claude, GPT, or any MCP-compatible agent
• Pull structured job data for matching, gap analysis, or market research
• Batch search multiple roles and locations from a single agent prompt
• No authentication required — works out of the box with Apify's hosted MCP server

Job Market Research

• Track hiring trends across roles, locations, and industries
• Monitor which companies are expanding (by volume of postings)
• Analyze salary ranges and experience requirements over time
• Compare seniority and employment-type mix across markets

Recruitment & Talent Intelligence

• Build sourcing pipelines across multiple job titles and cities at once
• Identify which companies are hiring for specific roles
• Track applicant counts to gauge competition for specific roles

---

Example tasks

Ready-to-run configurations for common jobs. Run one as-is, then swap in your own keywords, locations, or companies.

🧑‍💻 Scrape Software Engineer Jobs Posted Today (US)

Software engineer roles posted on LinkedIn in the last 24 hours, built for a daily feed. No login or API key. Add "keywords": "remote software engineer" if you want remote in the search text — LinkedIn exposes no work-arrangement filter to logged-out clients (see On remote / hybrid / on-site).

{
  "keywords": "software engineer",
  "location": "United States",
  "datePosted": "past_24_hours",
  "maxResults": 100
}

📈 Find New Sales Roles Companies Are Hiring for This Week

New Account Executive, SDR, and BDR openings from the past week. A company staffing up sales has budget: turn it into a prospect list.

{
  "keywordsList": ["account executive", "sales development representative", "business development representative"],
  "location": "United States",
  "datePosted": "past_week",
  "fetchJobDetails": true,
  "maxResults": 150,
  "maxResultsPerSearch": 50
}

🎯 Track Director Openings at Companies You're Watching

Director openings at a named list of companies. Put each company name in the search so LinkedIn surfaces its jobs, then filter to Director level. Use distinctive company names, since companyFilter matches by substring.

{
  "keywordsList": ["Stripe", "Plaid", "Brex", "Marqeta", "Adyen"],
  "location": "United States",
  "companyFilter": ["stripe", "plaid", "brex", "marqeta", "adyen"],
  "experienceLevel": "5",
  "fetchJobDetails": true,
  "maxResults": 500,
  "maxResultsPerSearch": 100
}

📊 Scrape Data and AI Jobs Across Top US Tech Cities

Three data and AI roles across four US tech hubs in one batch run, deduplicated and tagged by the search that found each job.

{
  "keywordsList": ["data engineer", "data scientist", "machine learning engineer"],
  "locationsList": ["New York, NY", "San Francisco, CA", "Austin, TX", "Seattle, WA"],
  "datePosted": "past_month",
  "maxResults": 600,
  "maxResultsPerSearch": 50
}

🕵️ Monitor One Company's New Job Postings Every Week

One company's new postings from the past week. Put the company name in the search, filter to it, and diff run over run to read where it is scaling.

{
  "keywords": "Stripe",
  "location": "United States",
  "datePosted": "past_week",
  "companyFilter": ["stripe"],
  "maxResults": 100
}

🏙️ Go Deeper Than 1,000 Results on a Nationwide Search

A country-wide search stops at LinkedIn's 1,000-per-query ceiling. Split it into the 15 largest US metros and each city gets its own 200, tagged by the city that found it. Note maxResults covers 15 x 200.

{
  "keywords": "registered nurse",
  "location": "United States",
  "splitByCity": true,
  "maxCities": 15,
  "maxResults": 3000,
  "maxResultsPerSearch": 200
}

🔗 Run a Search You Already Built on LinkedIn

Set the filters up on linkedin.com, copy the address bar, paste it in. Each URL keeps its own city and radius, so these two run as different searches.

{
  "searchUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=data%20engineer&location=Boise%2C%20Idaho&distance=100",
    "https://www.linkedin.com/jobs/search/?keywords=data%20engineer&location=Denver%2C%20Colorado&distance=5"
  ],
  "maxResults": 200,
  "maxResultsPerSearch": 100
}

🏥 Build a Weekly Nursing Job Feed for Any US Metro

Registered nurse and nurse practitioner roles posted this week across major US metros, tagged by city so rows route to the right recruiter.

{
  "keywordsList": ["registered nurse", "nurse practitioner"],
  "locationsList": ["New York, NY", "Los Angeles, CA", "Chicago, IL", "Houston, TX"],
  "datePosted": "past_week",
  "maxResults": 400,
  "maxResultsPerSearch": 50
}

---

Key features

• No API key, login, or cookies — scrapes public pages only
• No browser / no Playwright — pure HTTP, lower cost, faster execution
• Paste a search URL — copy it off linkedin.com, no retyping into fields
• City split — break a country into per-city searches to get past LinkedIn's 1,000-per-query ceiling
• Radius search — distance in miles around your location, verified server-side
• Parallel pagination — search pages fetched concurrently for up to ~4x faster runs
• Batch search — multiple keywords × locations in one run
• Throttle-aware — tells a rate-limited page apart from an exhausted one, and says so when a run may be short
• Full job details — description, seniority, employment type, job function, industry, applicant count
• Company info — employee count and industry, when LinkedIn shows them
• Title-only filter — keep only jobs whose title matches your keyword
• Description HTML — raw HTML alongside plain text
• Deduplication — jobId-based dedup across all batch searches
• Company filter — whitelist specific companies by name or slug
• Smart early-stop — abandons a search the moment its result pool is exhausted, saving compute and proxy cost
• MCP-ready — works as an AI agent tool via Apify's hosted MCP server
• Resume on migration — Apify state survives actor migrations mid-run

---

Output format

Each job returns a JSON object:

{
  "jobId": "3812345678",
  "title": "Senior Data Engineer",
  "company": "Stripe",
  "companyUrl": "https://www.linkedin.com/company/stripe",
  "location": "San Francisco, CA",
  "postedDate": "2 days ago",
  "postedDateTimestamp": "2026-03-18",
  "salary": "USD 180,000 - 240,000 / YEAR",
  "url": "https://www.linkedin.com/jobs/view/3812345678",

  "searchKeywords": "data engineer",
  "searchLocation": "United States",

  "description": "We are looking for a Senior Data Engineer...",
  "descriptionHtml": "<div class=\"show-more-less-html__markup\">...</div>",
  "seniorityLevel": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": "Engineering and Information Technology",
  "industries": "Financial Services",
  "applicantCount": "Over 200 applicants",

  "companyEmployeeCount": "1,001-5,000 employees",
  "companyIndustry": "Financial Services"
}

Fields description, descriptionHtml, seniorityLevel, employmentType, jobFunction, industries, applicantCount, and companyIndustry require fetchJobDetails: true. companyEmployeeCount requires fetchCompanyDetails: true. companyEmployeeCount and companyIndustry appear only when LinkedIn shows them on the job or company page. salary is returned without fetchJobDetails, but is filled in far more often with it — see On salary.

On salary

salary comes from the search card when LinkedIn prints a range there, which is uncommon — most cards carry no pay data at all. Enabling fetchJobDetails: true fills the gap: the job page is checked for a JSON-LD baseSalary block and then for a visible pay-range element, and either one is used when the card came back empty. A card value is never overwritten.

In a 3-row sample, listing-only returned no salary on any row while detail mode recovered a range on 2 of 3. If pay data matters to your use case, run with fetchJobDetails: true — it costs one extra request per job. Coverage still depends on the employer publishing a range at all, so expect gaps.

On remote / hybrid / on-site

This actor cannot filter by work arrangement, and does not pretend to.

LinkedIn's logged-out endpoints accept a work-arrangement filter and then ignore it. Measured on queries small enough to show an exact total:

query	no filter	remote	on-site	hybrid
prompt engineer @ Boise, ID	77	77	77	77
veterinary technician @ Missoula, MT	89	89	89	89

On-site and remote cannot both equal the unfiltered total if the filter runs. The returned job IDs are identical too, in the same order.

Nor is the arrangement readable per job: the guest search card doesn't carry it, and the guest detail page ships no JSON-LD and lists only Seniority level, Employment type, Job function and Industries. The Hybrid / Remote chip you see on linkedin.com is rendered only for logged-in users.

Earlier versions had a workType input and a workplaceType output column. Both were removed in 0.0.34: the column was derived from the requested filter, not from the job, so every row of a remote-filtered run was labelled remote whatever the job actually was. Reporting a value we never observed was worse than reporting nothing.

If you need this signal, enable fetchJobDetails and post-filter description for phrases like "hybrid", "on-site", or "days in office". That is a heuristic over employer prose, so treat it as a hint rather than a fact.

---

Input reference

Field	Type	Default	Description
searchUrls	string[]	—	Pasted linkedin.com search URLs. Each becomes one search, carrying its own keywords, location, geo ID, radius and date range. Overrides every field below
keywords	string	—	Single keyword search
location	string	—	Single location search
keywordsList	string[]	—	Batch keywords (overrides keywords)
locationsList	string[]	—	Batch locations (overrides location)
geoId	string	—	LinkedIn geo ID for precise location
distance	integer	LinkedIn default	Radius in miles around the location (0-100)
splitByCity	boolean	false	Expand a country location into one search per major city, to get past the 1,000-per-query cap (see note)
maxCities	integer	10	Cities per country when splitting, largest markets first (1-30)
companyFilter	string[]	—	Whitelist companies by name or slug
titleOnly	boolean	false	Keep only jobs whose title contains the keyword (see note below)
datePosted	select	any	past_24_hours, past_week, past_month
jobType	select	any	Full-time, Part-time, Contract, etc. — verified per job (see note)
experienceLevel	select	any	Entry, Associate, Mid-Senior, Director, etc. — verified per job (see note)
fetchJobDetails	boolean	false	Load full detail page per job (description, criteria, applicants)
fetchCompanyDetails	boolean	false	Also fetch each company's public page for employee count (one request per unique company, cached)
maxResults	integer	100	Cap on the whole run, across every search (max 10,000)
maxResultsPerSearch	integer	100	Cap per keyword/location combo; LinkedIn's own 1,000-per-query limit applies here (max 1,000)
proxyConfiguration	object	RESIDENTIAL	Proxy settings — residential recommended

Using titleOnly? Use plain keywords (e.g. product analyst, growth analyst), not Boolean strings. The title filter matches your text against the job title directly — it does not interpret LinkedIn Boolean operators like AND/OR or quotation marks. A keyword like "product" AND "analyst" with titleOnly: true will match nothing, because no job title literally contains that operator text. If you want Boolean search, set titleOnly: false and let LinkedIn's search engine handle the operators.

Batch runs: set maxResults to cover the batch. The two caps are different things. maxResultsPerSearch limits each keyword x location combination; maxResults limits the run as a whole, and the lower of the two wins. Leaving maxResults at its default of 100 while running 12 combinations at 50 each stops the run after two combinations, and the other ten never execute. Set maxResults to combinations x maxResultsPerSearch (12 x 50 = 600). Runs now warn at startup when the configuration would truncate, naming the value to use.

Using splitByCity? It multiplies the size of your run. Ten cities at maxResultsPerSearch: 100 is a 1,000-result run, and results are billed per item. The same rule as any batch applies: set maxResults to cities x maxResultsPerSearch, or the run stops part way and the remaining cities never execute. The startup warning names the number to use. Splitting only affects locations that name a supported country — a city or region is searched as typed, and if nothing splits the run says so rather than pretending it did.

Note on result counts with titleOnly: because LinkedIn has no native title-scope filter, results are filtered on our side — a niche role can return far fewer than maxResults. That's expected: the run stops automatically once every matching title is found, rather than padding with description-only matches.

---

Batch search example

Search for three roles across two cities in one run:

{
  "keywordsList": ["python developer", "data engineer", "ML engineer"],
  "locationsList": ["New York, NY", "San Francisco, CA"],
  "datePosted": "past_week",
  "fetchJobDetails": true,
  "maxResults": 300,
  "maxResultsPerSearch": 50
}

This runs 6 searches (3 × 2), returns up to 300 jobs, deduplicates, and tags each result with searchKeywords and searchLocation so you know which combo found it.

---

Lead generation example

Find hiring decision-makers at fintech companies:

{
  "keywordsList": ["engineering manager", "vp engineering", "head of engineering"],
  "locationsList": ["United States"],
  "companyFilter": ["stripe", "plaid", "brex", "ramp", "mercury"],
  "fetchJobDetails": true,
  "maxResults": 300,
  "maxResultsPerSearch": 100
}

Output includes job descriptions, seniority, employment type, industry, and applicant counts — ready to pipe into your CRM.

---

MCP Integration

Use this actor as a real-time tool for AI agents — no custom MCP server needed.

• Endpoint: https://mcp.apify.com?tools=labrat011/linkedin-jobs-scraper
• Auth: Authorization: Bearer <APIFY_TOKEN>
• Transport: Streamable HTTP
• Compatible with: Claude Desktop, Cursor, VS Code, Windsurf, Warp, Gemini CLI

Claude Desktop / Cursor config:

{
  "mcpServers": {
    "linkedin-jobs-scraper": {
      "url": "https://mcp.apify.com?tools=labrat011/linkedin-jobs-scraper",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}

Once connected, your AI agent can search LinkedIn jobs, pull full job details, and track hiring trends — all from a natural language prompt.

---

Proxy guidance

LinkedIn aggressively blocks datacenter IPs. Residential proxies are required. The actor defaults to Apify's RESIDENTIAL proxy group and will fail immediately on Apify if no proxy is configured — this saves you compute on a run that would never succeed anyway.

Without residential proxies, LinkedIn blocks the first request on almost every run. With residential proxies, the actor reliably handles large batch runs.

---

Timeout & memory guidance

The actor applies a short, jittered politeness delay and fetches up to 5 requests concurrently to stay under LinkedIn's radar without wasting time. Search pages are paginated in concurrent batches, and with fetchJobDetails: true each job's detail request fans out concurrently per page — so runtime scales gently with result count.

Max results	fetchJobDetails	Est. runtime	Recommended timeout
25 (free tier)	false (enforced)	~30 sec	120s
50	true	~1 min	300s
100	true	~2-3 min	600s
200	true	~4-5 min	900s
100	false (search only)	~15 sec	120s

Free tier note: Free users (25 results max) always run with fetchJobDetails: false — listing data only (title, company, location, salary, URL, posted date). Subscribe for full job details: description, seniority, employment type, job function, industry, and applicant count.

Proxy data cap: To protect against runaway proxy cost on blocked or pathological runs, the actor aborts early if a single run downloads far more data than its result count warrants (floor 25 MB + ~0.5 MB per requested result). It keeps and returns everything scraped up to that point. Lower maxResults or disable enrichment for very large runs.

Memory: 512MB is sufficient for all run sizes. 1-2GB is not needed unless you are running very large batch jobs (500+ results).

To set timeout in Apify: go to your actor run settings → Timeout → set in seconds.

---

Limitations

• LinkedIn caps search pagination at 1,000 results per query. splitByCity is the way past it: per-city searches return largely different jobs, so N cities is worth roughly N times the inventory rather than N slices of the same pool
• Salary data is only present when LinkedIn displays it on the listing or job page
• Company employee count and industry appear only when LinkedIn shows them
• fetchJobDetails adds one request per job — higher cost and runtime; enable only when you need the detail fields
• jobType and experienceLevel are enforced on our side against each job's published criteria, so they require fetchJobDetails and can return fewer rows than maxResults
• No work-arrangement filter. LinkedIn ignores it for logged-out clients and publishes no remote/hybrid/on-site value per job — see On remote / hybrid / on-site
• LinkedIn publishes no seniority for roughly half of postings (Not Applicable); with experienceLevel set, those rows are dropped and counted in the run summary
• Skills, company logo, and recruiter/hiring-manager data are login-gated by LinkedIn and not available from public pages, so they are not included