You can scrape LinkedIn jobs without logging in by hitting LinkedIn's public guest job-search endpoints, which return job listings as raw HTML to anonymous visitors. The cleanest path is https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search for listings and https://www.linkedin.com/jobs-guest/jobs/api/jobPosting/{jobId} for full descriptions — no auth, no cookies, no session tokens. If you don't want to maintain proxies and parsers, the LinkedIn Jobs Scraper – Fast & Affordable does the whole pipeline for $0.001 per job.
Quick Answer
A LinkedIn jobs scraper no login approach uses LinkedIn's public guest API — two undocumented endpoints that serve job results to logged-out visitors, paginated 25 jobs per request. You query with keywords, location, geoId, and start parameters, parse the returned HTML with a CSS selector library like Cheerio or BeautifulSoup, then hit the per-job endpoint for descriptions. No login means zero account bans, but LinkedIn rate-limits aggressively by IP, so you need rotating residential proxies past ~200 requests. Managed actors like the one on practical.tools handle proxies, parsing, and retries at $1 per 1,000 jobs.
How does the LinkedIn guest API work?
LinkedIn exposes two unauthenticated endpoints to support its public job-search pages (the ones Google indexes). They're the same endpoints your browser hits when you visit a /jobs/search URL in incognito mode.
Endpoint 1 — listings (paginated):
GET https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search
?keywords=python+developer
&location=Berlin
&geoId=106967730
&start=0
This returns raw HTML — a list of <li> elements, each wrapping a job card with the job title, company name, location, posted date, and a data-entity-urn attribute containing the numeric job ID. Pagination uses start in increments of 25.
Endpoint 2 — single job detail:
GET https://www.linkedin.com/jobs-guest/jobs/api/jobPosting/3812345678
Returns the full job description as HTML, plus seniority level, employment type, job function, and industries. The jobId comes from the listing endpoint.
Both endpoints respond to plain GET requests with no auth headers required. The trade-off: these are guest views, so you don't get applicant counts, recruiter contact info, or "easy apply" data — just public posting content.
Why scrape without logging in?
Three concrete reasons logged-out scraping wins for most use cases:
- No account bans. LinkedIn aggressively detects automation on logged-in sessions. Burner accounts get restricted within 50–500 requests. With guest API, the worst case is an IP block — fix it with a new IP.
- No 2FA/cookie management. Logged-in scrapers break every time a session expires (typically 24–72 hours). Guest scrapers don't have sessions to manage.
- Legal clarity. The 2022 hiQ Labs v. LinkedIn ruling confirmed that scraping publicly accessible data (no login wall) doesn't violate the CFAA. Logged-in scraping is a murkier zone.
The cost: you lose ~10 fields that are only visible to logged-in users (number of applicants, hiring manager, "your network at this company," etc.). For job-board aggregation, market research, or recruiting pipelines, the guest fields are enough.
What fields can you extract without login?
From the listings endpoint:
- Job title
- Company name + LinkedIn company URL
- Location (city, region, country)
- Posted date (relative — "2 days ago")
- Job ID
- Direct job URL
- Remote/hybrid/on-site flag (sometimes)
From the per-job endpoint:
- Full job description (HTML)
- Seniority level (Entry, Mid-Senior, Director, etc.)
- Employment type (Full-time, Contract, Part-time)
- Job functions (Engineering, Sales, etc.)
- Industries
- Salary range (only when posted by employer — ~15% of US jobs, less elsewhere)
What you don't get: applicant count, "easy apply" indicator, recruiter profile, company employee count overlap.
How do you build a LinkedIn jobs scraper with no login?
Here's a minimal Python version using requests and BeautifulSoup:
import requests
from bs4 import BeautifulSoup
import time
def scrape_linkedin_jobs(keywords, location, max_jobs=100):
base = "https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search"
headers = {"User-Agent": "Mozilla/5.0"}
jobs = []
for start in range(0, max_jobs, 25):
params = {
"keywords": keywords,
"location": location,
"start": start
}
r = requests.get(base, params=params, headers=headers)
if r.status_code != 200:
break
soup = BeautifulSoup(r.text, "html.parser")
cards = soup.find_all("li")
if not cards:
break
for card in cards:
title = card.find("h3", class_="base-search-card__title")
company = card.find("h4", class_="base-search-card__subtitle")
loc = card.find("span", class_="job-search-card__location")
link = card.find("a", class_="base-card__full-link")
if title and company:
jobs.append({
"title": title.get_text(strip=True),
"company": company.get_text(strip=True),
"location": loc.get_text(strip=True) if loc else None,
"url": link["href"].split("?")[0] if link else None,
})
time.sleep(2) # rate-limit yourself
return jobs
results = scrape_linkedin_jobs("data engineer", "Amsterdam", max_jobs=200)
print(f"Got {len(results)} jobs")
This works for ~100–200 jobs from a single residential IP. Past that, expect HTTP 429 or 999 responses. To scale you need:
- Rotating residential proxies ($1.50–$15 per GB across providers)
- Retry logic with exponential backoff
- A separate worker pulling job descriptions from endpoint 2
- Deduplication by job ID
A weekend project becomes 200+ lines of code with proxy juggling, error handling, and DOM-change monitoring.
What's the cheapest way to scrape LinkedIn jobs at scale?
Pricing comparison for 10,000 jobs scraped (full details, including descriptions):
| Tool | Price for 10K jobs | Login required? |
|---|---|---|
| Build it yourself + Bright Data proxies | ~$30–60 in proxy bandwidth + dev time | No |
| Browse.ai | ~$190 (premium plan needed for volume) | No |
| Scrapfly | ~$50–100 depending on plan | No |
| Bright Data dataset | ~$150 (1.5¢/record) | No |
| practical.tools LinkedIn Jobs Scraper | $10 | No |
The LinkedIn Jobs Scraper – Fast & Affordable charges $0.001 per job with pay-per-result billing — meaning failed scrapes don't count. No subscription, no minimums. 10,000 jobs costs $10. 100,000 jobs costs $100.
Under the hood it does what your DIY version would do: hits the guest API, rotates proxies, parses HTML, fetches descriptions, dedupes. The actor runs on Apify, returns JSON or CSV, and integrates with webhooks, Zapier, Make, and direct API calls.
How do you avoid getting blocked?
Even without login, LinkedIn watches IPs. Rules of thumb that keep block rates under 2%:
- Cap concurrency at 3–5 requests/second per IP. More than that triggers 429s within minutes.
- Use residential or mobile proxies, not datacenter. Datacenter IPs get HTTP 999 (LinkedIn's "go away" status) within ~50 requests.
- Rotate User-Agent strings. A pool of 20+ recent Chrome/Firefox UAs is enough.
- Don't follow internal redirects to logged-in pages. Set
allow_redirects=Falseand check status codes manually. - Spread queries across geos. Hitting
geoId=103644278(USA) for 5,000 requests is more suspicious than mixing 10 geos. - Add jitter. Random sleep 1.5–4s between requests beats fixed 2s.
Managed actors handle all six of these by default. If you're scraping more than ~5,000 jobs/month, the build-vs-buy math almost always favors buy.
FAQ
Q: Is scraping LinkedIn jobs without login legal? The 2022 Ninth Circuit ruling in hiQ Labs v. LinkedIn established that scraping publicly accessible data does not violate the Computer Fraud and Abuse Act. Job postings shown to logged-out users are public. You should still respect robots.txt directives and avoid republishing scraped data verbatim without attribution.
Q: How many jobs can I scrape per search query?
LinkedIn's guest API caps results at roughly 1,000 per query (40 pages of 25). To go deeper, segment by location, posted date (f_TPR=r86400 for last 24h), seniority, or job function. A query like "python developer, USA" returns ~1,000; the same split into 50 states returns 30,000+.
Q: Do I need proxies for small-scale scraping? For under 100 jobs in a single run, your home IP usually works. Past 200 requests/hour from one IP, expect rate-limiting. Residential proxies cost $1–4 per GB; one job listing fetch is roughly 30–80 KB, so 10,000 jobs uses about 500 MB.
Q: How fresh is the data from the guest API? The guest endpoints serve the same index as the public job search pages, typically updated within 5–15 minutes of a posting going live. Posted dates are relative ("2 hours ago"), so you'll need to compute absolute timestamps from your scrape time.
Q: Can I get applicant counts or salary data without logging in? Applicant counts are logged-in-only — they're not in the guest response. Salary ranges appear only when the employer explicitly added them, which is roughly 15% of US listings (driven by state pay-transparency laws) and under 5% elsewhere. For comprehensive salary data you'd need to combine LinkedIn data with Levels.fyi or Glassdoor.