LinkedIn APIlinkedin.com ↗
Search LinkedIn's public job board and retrieve full job details via 3 endpoints. Filter by job type, location, salary, experience level, and workplace type.
What is the LinkedIn API?
This API exposes 3 endpoints for querying LinkedIn's public job board and retrieving structured posting data. Use search_jobs to run keyword searches filtered by location, salary, job type, experience level, workplace type, and recency — getting back job cards with IDs, titles, companies, and URLs. Feed those IDs into get_job_details to retrieve full descriptions, seniority level, job function, industry classification, applicant counts, and external apply URLs.
curl -X GET 'https://api.parse.bot/scraper/63156746-cbe3-420a-84ff-704dee742857/search_jobs?limit=5&start=0&salary=6&job_type=F&keywords=software+engineer&location=United+States&time_period=r86400&workplace_type=1&experience_level=1' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace linkedin-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: LinkedIn Jobs SDK — search, filter, and drill into job postings."""
from parse_apis.linkedin_jobs_search_api import (
LinkedIn, JobType, ExperienceLevel, WorkplaceType, TimePeriod, Salary, JobNotFound
)
linkedin = LinkedIn()
# Discover available filters and their accepted values
filters = linkedin.filteroptionses.get()
print(filters.job_type.description, filters.job_type.options)
# Search for remote senior data engineering jobs posted in the past week
for job_summary in linkedin.jobsummaries.search(
keywords="data engineer",
location="New York",
job_type=JobType.FULL_TIME,
workplace_type=WorkplaceType.REMOTE,
experience_level=ExperienceLevel.MID_SENIOR,
time_period=TimePeriod.PAST_WEEK,
salary=Salary.USD_120K,
limit=5,
):
print(job_summary.title, job_summary.company, job_summary.location)
# Drill into the first result's full details
first = linkedin.jobsummaries.search(keywords="python developer", limit=1).first()
if first:
detail = first.details()
print(detail.title, detail.company, detail.applicants)
if detail.criteria:
print(detail.criteria.seniority_level, detail.criteria.employment_type)
# Fetch a job directly by ID with error handling
try:
job = linkedin.jobs.get(job_id="4407498584")
print(job.title, job.company, job.location)
except JobNotFound as exc:
print(f"Job not found: {exc.job_id}")
print("exercised: filteroptionses.get / jobsummaries.search / jobsummary.details / jobs.get")
Full-text search over LinkedIn's public job board. Supports filtering by job type, experience level, workplace type, salary range, and posting recency. Paginates in increments of 25 via the start parameter. Returns job cards with basic metadata; use get_job_details for the full posting.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of results to return |
| start | integer | Pagination offset (increments of 25) |
| salary | string | Minimum salary filter. |
| job_type | string | Employment type filter. |
| keywords | string | Search keywords (job title, skills, etc.) |
| location | string | Location to search in (city, state, country) |
| time_period | string | Time posted filter. |
| workplace_type | string | Workplace type filter. |
| experience_level | string | Experience level filter. |
{
"type": "object",
"fields": {
"jobs": "array of job card objects with job_id, title, company, company_url, location, posted_date, posted_text, job_url, company_logo",
"total_returned": "integer count of jobs returned",
"filters_applied": "object with active filter values (keywords, location, job_type, experience_level, workplace_type, time_period, salary)"
},
"sample": {
"data": {
"jobs": [
{
"title": "Software Engineer, New Grad",
"job_id": "4406118990",
"company": "Notion",
"job_url": "https://www.linkedin.com/jobs/view/software-engineer-new-grad-at-notion-4406118990",
"location": "San Francisco, CA",
"company_url": "https://www.linkedin.com/company/notionhq",
"posted_date": "2026-06-05",
"posted_text": "5 days ago",
"company_logo": "https://media.licdn.com/dms/image/v2/D4E0BAQGwvcv_1tHZ4w/company-logo_100_100/notionhq_logo"
}
],
"total_returned": 5,
"filters_applied": {
"salary": null,
"job_type": null,
"keywords": "software engineer",
"location": "United States",
"time_period": null,
"workplace_type": null,
"experience_level": null
}
},
"status": "success"
}
}About the LinkedIn API
Searching Jobs
The search_jobs endpoint accepts keywords (job title, skills, or any free-text query) alongside a location string that can be a city, state, or country. Results paginate in increments of 25 via the start offset parameter. Each job card in the jobs array includes job_id, title, company, company_url, location, posted_date, posted_text, job_url, and company_logo. The response also echoes back a filters_applied object so you can confirm which filters were active on a given request.
Filtering Options
Four discrete filter dimensions are available alongside keywords and location: job_type (e.g. full-time, contract, part-time), experience_level, workplace_type (on-site, remote, hybrid), time_period (recency of posting), and salary (minimum salary threshold). If you want to programmatically enumerate accepted values before building a UI, call get_filters — it returns each filter's accepted option codes and their display labels without requiring any parameters.
Job Detail Fields
get_job_details takes a single required job_id (the numeric string from search_jobs results) and returns the complete posting. Notable fields include description (full text of the posting), criteria (an object containing seniority_level, employment_type, job_function, and industries), applicants (the applicant count text as shown on the listing), and apply_url (the external application link when LinkedIn exposes one). Fields like apply_url and applicants are returned as null when the source listing does not include them.
Coverage Notes
All three endpoints target LinkedIn's public job board — postings that are visible without authentication. Data freshness tracks the live listings, and posted_text / posted_date reflect the recency label attached to each posting. Pagination through large result sets is supported but bounded by the limit and start parameters on search_jobs.
The LinkedIn API is a managed, monitored endpoint for linkedin.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when linkedin.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official linkedin.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a job aggregator that pulls listings by keyword and location using
search_jobsand displays company logos and posting dates. - Track applicant counts on specific job IDs over time using
get_job_detailsto gauge competition for roles. - Power a remote-work job board by filtering
search_jobswithworkplace_typeset to remote. - Populate a recruiting dashboard that enriches job cards with full descriptions and apply URLs from
get_job_details. - Dynamically render filter dropdowns in a job search UI using the option maps returned by
get_filters. - Analyze salary range availability by querying
search_jobswith differentsalarythresholds across the same keyword set. - Aggregate job postings by industry or job function using the
criteria.industriesandcriteria.job_functionfields fromget_job_details.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does LinkedIn have an official developer API for job listings?+
What does `get_job_details` return beyond what `search_jobs` provides?+
search_jobs returns lightweight job cards: job_id, title, company, location, posted_text, job_url, and company_logo. get_job_details adds the full description text, the structured criteria object (seniority level, employment type, job function, industries), the applicants count, and the external apply_url when available.Does the API return LinkedIn company profile data or employee information?+
How does pagination work in `search_jobs`?+
start offset parameter. To get the second page of results, set start to 25; for the third page, set it to 50. The total_returned field in each response tells you how many job cards were returned in that call, not the total available on LinkedIn.Can I filter by a specific company name in `search_jobs`?+
company filter parameter. You can include a company name in the keywords field to bias results toward that employer, but the endpoint does not guarantee company-scoped filtering the way job_type, experience_level, or workplace_type do. You can fork this API on Parse and revise it to add a dedicated company filter if that endpoint surface is available.