linkedin-job-mcp
This server lets AI apps search LinkedIn jobs, fetch full job details, and assess postings for ghost-job risk.
Search jobs by keyword, location/city/country/geoId, date posted, job type, remote preference, experience level, salary, verification, applicant count, sort order, pagination, and limit.
Retrieve one job’s full description, seniority, employment type, industries, posting age, applicant count, salary, and application status.
Grade a posting with Ghost Job Radar for ghost-job likelihood, competition/chance, and employer-response signals, using a job link or pasted ad text; optionally check company news.
Access the tools through MCP over stdio or HTTP, plus the project’s REST API, CLI, Windows setup app, and local radar dashboard.
Optional Ghost Job Radar data source that ingests job postings from Google for Jobs to help assess ghost-job risk.
LinkedIn Jobs MCP
LinkedIn job search and full job details for your AI apps, plus Ghost Job Radar, a dashboard that shows which job postings are likely not really open. A Windows app connects itself to Claude Code, Codex, VS Code and other MCP clients; the same tools also come as an npm package, a REST API and a command line.

Tools
Tool | What your AI app gets |
| Jobs by keyword and location, filtered by date, job type, remote work or fewer than 10 applicants |
| One job's full description, seniority, employment type, industries, posting age and applicant count |
| Ghost Job Radar's grade for one posting: how likely it is a ghost job, your chance against the competition, and the facts behind it. Needs the radar running |
It reads LinkedIn's public job pages, so it needs no account and no browser. Requests are spaced out and cached.
Related MCP server: job-radar
Ghost Job Radar
A dashboard on your computer that grades every job it sees for ghost-job risk: postings that stay up far longer than usual for their occupation, reposts with unchanged text, jobs gone from the employer's own site, start dates long past, talent-pool wording, layoff news while still hiring, and what you know about the employer. Every job gets three separate verdicts: ghost-risk, your chance, and whether the employer answers.

linkedin-jobs-mcp radarWith the Windows app, choose 5 in its menu or run .\linkedin-jobs-mcp.exe radar. It needs
Python 3.11 or newer. The first start sets up the radar's Python environment;
every start also runs the LinkedIn source, so LinkedIn search and job pages work right away. Your data stays on your
computer, in %LOCALAPPDATA%\linkedin-jobs-mcp\radar (macOS: ~/Library/Application Support/linkedin-jobs-mcp/radar,
Linux: ~/.local/share/linkedin-jobs-mcp/radar). A .env file there switches on more sources, such as the
Bundesagentur job board or Google for Jobs; radar/README.md explains every view, signal and source.

Install
Windows app
Download
linkedin-jobs-mcp.exefrom the latest release. It is one file with Node.js inside.Double-click it. The file is not code-signed, so Windows may say "Windows protected your PC": choose More info → Run anyway.
Choose 1 Install and connect the apps found. The app copies itself to
%LOCALAPPDATA%\Programs\linkedin-jobs-mcp\and adds itself to every supported app it finds.Restart those apps. The app has no window of its own: they start it in the background when they need the tools.

npm (Windows, macOS, Linux)
Needs Node.js 18 or newer.
npm install -g linkedin-jobs-mcp
linkedin-jobs-mcp connectOr add it to an app by hand, through npx:
{
"mcpServers": {
"linkedin-jobs": { "command": "npx", "args": ["-y", "linkedin-jobs-mcp"] }
}
}On Windows, some apps need "command": "cmd", "args": ["/c", "npx", "-y", "linkedin-jobs-mcp"].
From source
git clone https://github.com/GhoshSrinjoy/linkedin-job-mcp.git
cd linkedin-job-mcp
npm install
npm run app -- connectConnect your apps
App | Name for | Where the setting goes |
Claude Code |
|
|
Codex |
|
|
VS Code |
|
|
VS Code Insiders |
|
|
Claude Desktop |
|
|
Cursor |
|
|
Windsurf |
|
|
Gemini CLI |
|
|
LM Studio |
|
|
Cline |
|
|
connect only adds or replaces the linkedin-jobs entry: other servers and settings stay, and the first change keeps a
copy of the file next to it (<file>.linkedin-jobs.bak). A settings file with comments is left unchanged, and the
entry to add is printed instead.

Commands
Command | What it does |
| The setup menu in a console window; the MCP server when an app starts it |
| Copy the Windows app to |
| Connect the apps found, or only the named ones (also when they are not found) |
| Remove the connection from every app, or only from the named ones |
| Which apps are found and connected |
| Print the settings to add by hand |
| REST API plus MCP over HTTP |
| MCP over stdio (what the connected apps run) |
| One job's details as JSON |
| Search from the command line |
| Open Ghost Job Radar |
| Disconnect every app and remove the installed Windows app |
With the Windows app, run them from its folder, for example .\linkedin-jobs-mcp.exe status.
Add it by hand
Every app needs the same thing: the program, started with the mcp argument. VS Code (mcp.json):
{
"servers": {
"linkedin-jobs": {
"type": "stdio",
"command": "C:\\Users\\you\\AppData\\Local\\Programs\\linkedin-jobs-mcp\\linkedin-jobs-mcp.exe",
"args": ["mcp"]
}
}
}Claude Desktop, Cursor, Windsurf, Gemini CLI, LM Studio and Cline take the same entry under "mcpServers", without
"type". Codex (config.toml):
[mcp_servers.linkedin-jobs]
command = "C:\\Users\\you\\AppData\\Local\\Programs\\linkedin-jobs-mcp\\linkedin-jobs-mcp.exe"
args = ["mcp"]Claude Code:
claude mcp add --scope user linkedin-jobs -- "C:\Users\you\AppData\Local\Programs\linkedin-jobs-mcp\linkedin-jobs-mcp.exe" mcpOllama, through mcp-client-for-ollama: save the mcpServers
entry in a file and start ollmcp -j servers.json.
linkedin-jobs-mcp config prints all of these with the real path.
MCP over HTTP
Apps that connect by URL can use the HTTP server instead. Start linkedin-jobs-mcp serve (or npm run api) and add
http://127.0.0.1:3000/mcp:
claude mcp add --transport http linkedin-jobs http://127.0.0.1:3000/mcp{ "servers": { "linkedin-jobs": { "type": "http", "url": "http://127.0.0.1:3000/mcp" } } }The server listens on this computer only and refuses requests that name another host, so web pages cannot reach it
through DNS rebinding. HOST=0.0.0.0 makes it reachable from other machines, for example from a container; protect
it yourself then.
Search options
Option | Values |
| Job title or keywords, e.g. |
| City, region or country, e.g. |
| Narrow the location |
| LinkedIn location id, skips the location lookup |
|
|
|
|
|
|
| Jobs with fewer than 10 applicants |
| Number of jobs (default 10; 25 in the REST API) |
|
|
| Page of results, from 0; a page is |
The REST API accepts the same options. LinkedIn's public search ignores salary, experience level and verified-job filters, so there are none.
Responses
A search returns:
{
"success": true,
"total_jobs": 1,
"jobs": [
{
"position": "Data Engineer (m/w/d)",
"company": "Example GmbH",
"location": "Berlin, Berlin, Germany",
"date": "2026-10-20",
"agoTime": "4 days ago",
"salary": "Not specified",
"jobUrl": "https://www.linkedin.com/jobs/view/1234567890/",
"companyLogo": "https://media.licdn.com/…"
}
],
"search_params": { "keyword": "data engineer", "location": "Berlin, Germany", "limit": "10" }
}Job details return:
{
"id": "1234567890",
"position": "Data Engineer (m/w/d)",
"company": "Example GmbH",
"location": "Berlin, Berlin, Germany",
"postedAgo": "3 weeks ago",
"applicants": "Over 200 applicants",
"salary": null,
"seniority": "Mid-Senior level",
"employmentType": "Full-time",
"jobFunction": null,
"industries": "Software Development",
"criteria": { "Seniority level": "Mid-Senior level", "Employment type": "Full-time", "Industries": "Software Development" },
"acceptingApplications": true,
"description": "We are looking for a data engineer to join our platform team. …",
"jobUrl": "https://www.linkedin.com/jobs/view/1234567890/"
}A job LinkedIn no longer has returns { "id": "…", "removed": true }.
REST API
npm run api or linkedin-jobs-mcp serve starts it on http://127.0.0.1:3000.
Endpoint | What it does |
| Search, with the options above as a JSON body; returns |
| One job's details; 404 when LinkedIn no longer has it, 400 for an invalid id or link |
| MCP over Streamable HTTP |
|
|
Library
const { query, getJobDetails } = require("linkedin-jobs-mcp");
const jobs = await query({ keyword: "data engineer", location: "Berlin, Germany", limit: "10" });
const job = await getJobDetails("https://www.linkedin.com/jobs/view/1234567890/");Configuration
Set these in the environment or in a .env file in the folder you start it from.
Variable | Default | What it sets |
|
| Port of the REST API and MCP over HTTP |
|
| Address the server listens on |
|
| Timeout of one request to LinkedIn |
|
| How long search results stay cached |
|
| Minimum gap between two job-page requests |
|
| How long job details stay cached |
| User agent for job-page requests | |
|
| Rate-limit window of the REST API |
|
| Requests per window and address |
Build the Windows app
On Windows with Node.js 20 or newer:
npm install
npm run build:win # dist/linkedin-jobs-mcp.exe and its SHA-256The build bundles the code with esbuild and injects it into a copy of node.exe (a Node.js single executable
application). Pushing a tag such as v1.2.0 builds the app on GitHub Actions and attaches it to a release.
Tests
npm test # job pages, settings files, the MCP server and the HTTP API
cd radar && python -m pytest # Ghost Job RadarBoth run offline.
Repository layout
Path | What it is |
| LinkedIn search and job details |
| MCP server (stdio and HTTP) and REST API |
| The app: commands, client setup, starting the radar |
| Ghost Job Radar (Python): dashboard, scoring, research report and notes, browser extension |
| Builds the Windows app |
| Tests of the Node part |
Responsible use
The tools read public job pages slowly and cache what they read, for personal job searching and research. Automated access can conflict with LinkedIn's User Agreement, so keep the volume low and use it at your own risk.
License
PolyForm Noncommercial 1.0.0: free for personal, research and other non-commercial use. For commercial use, ask for permission.
Srinjoy Ghosh (@GhoshSrinjoy, ghoshsrinjoy97@gmail.com)
Available Tools
3 toolscheck_ghost_jobA
Grade a job posting with Ghost Job Radar: how likely it is to be a ghost job (not really open), your chance against the competition, and the facts behind the grade. Needs the radar running (linkedin-jobs-mcp radar)
| Name | Required | Description | Default |
|---|---|---|---|
| job | Yes | Job link (LinkedIn, the employer's site or a job board) or the pasted ad text | |
| company | No | Company name, when the job is pasted text | |
| with_news | No | Also check company news (slower) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It discloses the radar prerequisite and summarizes the outputs, but it does not state whether the operation is read-only, what happens on failure, or any rate/latency constraints beyond the schema's with_news note.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and outputs, with the prerequisite appended without excess. It does not waste space restating schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so the description should convey return values; it does at a high level by naming ghost likelihood, competition chance, and supporting facts. Combined with full schema coverage and the radar prerequisite, it is mostly complete, though it omits failure and availability details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents job, company, and with_news. The description adds no parameter-level meaning beyond saying it grades a job posting, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb, "Grade," and resource, "job posting," and names the distinct outputs: ghost-job likelihood, competition chance, and supporting facts. This clearly differentiates it by function from the sibling detail and search tools, even without naming them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides a prerequisite that the radar must be running and implies the tool is for ghost-job assessment. However, it does not explicitly say when to choose it over get_linkedin_job_details or search_linkedin_jobs, nor when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_linkedin_job_detailsA
Get one LinkedIn job's full description, criteria (seniority, employment type, industries), posted time and the applicant count shown on the public job page
| Name | Required | Description | Default |
|---|---|---|---|
| job | Yes | LinkedIn job id (e.g. '1234567890') or job URL |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does usefully disclose the return payload (criteria fields, posted time, applicant count as shown publicly). It says nothing about failure behavior for an invalid or expired job id, whether the applicant count can be absent, scoping to public page data, or any auth/rate constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is a single front-loaded sentence with no filler, and the enumerated return fields are the most valuable part. The nested parenthetical and the trailing 'shown on the public job page' make it slightly dense but not wasteful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read lookup with no output schema, the description adequately covers what comes back, which is the main thing an agent needs. The remaining gap is error/edge-case behavior for unresolvable job identifiers, a minor omission given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is a single required 'job' parameter and schema coverage is 100%, with the schema itself documenting that it accepts a job id or a job URL. The description adds no extra meaning such as URL formats accepted or whether a slug-only URL works, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and enumerates the resource precisely: one job's full description, criteria (seniority, employment type, industries), posted time, and applicant count. The word 'one' plus 'full description' implicitly contrasts with search_linkedin_jobs, but no sibling is named explicitly, so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer this is the drill-down call after search_linkedin_jobs returns job ids, but the description never states when to use it, when not to, or why to prefer it over check_ghost_job. No prerequisites or alternate paths are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_linkedin_jobsA
Find open jobs on LinkedIn by keyword and location, newest first. Read-only: it reads LinkedIn's public job search without signing in, spaces its requests out and keeps each search for an hour, so repeating a search answers at once. Returns JSON with total_jobs and jobs, each with position, company, location, date, agoTime, salary (when LinkedIn shows one), jobUrl and companyLogo; on failure, such as LinkedIn limiting requests, success is false with an error. LinkedIn serves 10 jobs per request, so every 10 jobs asked for add about a second. Use get_linkedin_job_details on a jobUrl for the full description and applicant count, and check_ghost_job to see whether a posting is really open.
| Name | Required | Description | Default |
|---|---|---|---|
| city | No | City to search in; when given, it is searched instead of location, e.g. 'Munich' | |
| page | No | Which page of results, from '0'. A page is limit jobs long: page '1' with limit '10' returns jobs 11 to 20 | 0 |
| geoId | No | LinkedIn's numeric location id, e.g. '103644278' for the United States. Use it when a place name finds the wrong location | |
| limit | No | How many jobs to return, as a number in a string, e.g. '25' | 10 |
| sortBy | No | 'recent' for newest first or 'relevant' for LinkedIn's best matches first | recent |
| country | No | Country to search in when location is left out, e.g. 'Germany' | |
| jobType | No | Only this type of employment. Leave out for all types | |
| keyword | No | Job title, skill or company, e.g. 'data engineer'. Leave out to list all jobs in the location | |
| location | No | City, region or country, e.g. 'Berlin, Germany'. Leave out to search worldwide | |
| remoteFilter | No | Only this workplace type. Leave out for all | |
| dateSincePosted | No | Only jobs posted within this period ('24hr' and 'today' mean the past 24 hours). Leave out for any date | |
| under_10_applicants | No | Only jobs that fewer than 10 people have applied to so far |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations supplied, the description carries the full burden and does so: read-only, no sign-in required, request spacing, one-hour per-search caching, the 10-jobs-per-request latency cost, and the failure mode (success false plus error when LinkedIn rate-limits). It even documents the response fields despite no output schema existing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Structure is front-loaded: purpose first, then behavioral traits, then sibling routing. The long second sentence uses semicolons and colons densely but every clause carries distinct operational information, and nothing is repeated from the schema or title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 12-parameter, zero-required, mutation-free tool with no annotations and no output schema, the description supplies the return shape, failure behavior, latency model, caching semantics, and next-step tools. An agent has everything needed to call it correctly and to interpret a result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3 and the schema already documents city, geoId, page/limit, and the enum filters. The description still adds genuinely useful meaning beyond the schema by explaining that LinkedIn serves results in batches of 10 and that each batch costs roughly a second, which informs how to set limit and page.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening line names a specific verb and resource ("Find open jobs on LinkedIn") and pins the default ordering ("newest first"). It is immediately distinguishable from the two siblings, which are named later with their distinct roles.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It routes the agent explicitly: use get_linkedin_job_details on a returned jobUrl for descriptions/applicant counts, and check_ghost_job to verify a posting is real. That is clear alternate-tool guidance. It stops short of stating when not to use this tool at all (e.g., non-job searches), so it is short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
v1.3.3- Changed
search_linkedin_jobs24 fields changed- removed
Input schema / properties / city / defaultRemoved value: -"" - changed
Input schema / properties / city / descriptionPrevious value: -"Optional city to refine location (e.g., 'Berlin')"New value: +"City to search in; when given, it is searched instead of location, e.g. 'Munich'" - removed
Input schema / properties / country / defaultRemoved value: -"" - changed
Input schema / properties / country / descriptionPrevious value: -"Optional country to refine location (e.g., 'Germany')"New value: +"Country to search in when location is left out, e.g. 'Germany'" - removed
Input schema / properties / dateSincePosted / defaultRemoved value: -"" - changed
Input schema / properties / dateSincePosted / descriptionPrevious value: -"Date range for job posting"New value: +"Only jobs posted within this period ('24hr' and 'today' mean the past 24 hours). Leave out for any date" - changed
Input schema / properties / dateSincePosted / enumPrevious value: -[ - "past month", - "past week", - "past 24 hours", - "24hr", - "today" -]New value: +[ + "past 24 hours", + "past week", + "past month", + "24hr", + "today" +] - removed
Input schema / properties / experienceLevelRemoved value: -{ - "default": "", - "description": "Experience level required", - "enum": [ - "internship", - "entry level", - "associate", - "senior", - "director", - "executive" - ], - "type": "string" -} - removed
Input schema / properties / geoId / defaultRemoved value: -"" - changed
Input schema / properties / geoId / descriptionPrevious value: -"Optional LinkedIn geoId to bypass location guessing (e.g., '103644278')"New value: +"LinkedIn's numeric location id, e.g. '103644278' for the United States. Use it when a place name finds the wrong location" - removed
Input schema / properties / has_verificationRemoved value: -{ - "default": false, - "description": "Filter for verified jobs only", - "type": "boolean" -} - removed
Input schema / properties / jobType / defaultRemoved value: -"" - changed
Input schema / properties / jobType / descriptionPrevious value: -"Type of employment"New value: +"Only this type of employment. Leave out for all types" - removed
Input schema / properties / keyword / defaultRemoved value: -"" - changed
Input schema / properties / keyword / descriptionPrevious value: -"Job search keyword (e.g., 'software engineer')"New value: +"Job title, skill or company, e.g. 'data engineer'. Leave out to list all jobs in the location" - changed
Input schema / properties / limit / descriptionPrevious value: -"Maximum number of jobs to return"New value: +"How many jobs to return, as a number in a string, e.g. '25'" - removed
Input schema / properties / location / defaultRemoved value: -"" - changed
Input schema / properties / location / descriptionPrevious value: -"Location to search for jobs (e.g., 'Berlin, Germany')"New value: +"City, region or country, e.g. 'Berlin, Germany'. Leave out to search worldwide" - changed
Input schema / properties / page / descriptionPrevious value: -"Page number (0-based)"New value: +"Which page of results, from '0'. A page is limit jobs long: page '1' with limit '10' returns jobs 11 to 20" - removed
Input schema / properties / remoteFilter / defaultRemoved value: -"" - changed
Input schema / properties / remoteFilter / descriptionPrevious value: -"Remote work preference"New value: +"Only this workplace type. Leave out for all" - removed
Input schema / properties / salaryRemoved value: -{ - "default": "", - "description": "Minimum salary", - "enum": [ - "40000", - "60000", - "80000", - "100000", - "120000" - ], - "type": "string" -} - changed
Input schema / properties / sortBy / descriptionPrevious value: -"Sort results by"New value: +"'recent' for newest first or 'relevant' for LinkedIn's best matches first" - changed
Input schema / properties / under_10_applicants / descriptionPrevious value: -"Filter for jobs with under 10 applicants"New value: +"Only jobs that fewer than 10 people have applied to so far"
3 tool updates
v1.3.0- First observed
check_ghost_job - First observed
get_linkedin_job_details - First observed
search_linkedin_jobs
TDQS
Scored across 3 tools
Each tool maps to a distinct step in a job-hunting workflow: search a list, fetch one posting's full details, and grade a posting for ghost-job likelihood. The descriptions explicitly cross-reference each other (use get_linkedin_job_details on a jobUrl, check_ghost_job for openness), leaving no realistic path for misselection.
All three names use the same snake_case verb_noun pattern: search_linkedin_jobs, get_linkedin_job_details, check_ghost_job. Object naming is consistent (linkedin_job / job) and the verbs accurately signal the action.
Three tools cover the entire stated scope with no redundancy, which is defensible for a narrow, single-domain server. It sits at the lean edge of the scale, so users needing richer filtering must rely on the search tool's parameters alone.
The search → inspect → validate loop is fully closed, with salary, applicant count, and ghost-job grading all reachable. Minor gaps remain: no company-based lookup, no way to enumerate more than what a keyword search returns, and check_ghost_job hard-depends on a separately running local radar process.
Maintenance
Related MCP Connectors
AI job search and tracker: jobs near you and remote, pay vs market, ghost-job risk, resume checker.
Jobs from LinkedIn, Indeed and company sites via Google Jobs: salaries, apply links, alerts.
Open jobs from 20,000+ company career sites: search, list a company's roles, read full job ads
Job search over employers' own hiring systems. Search with no key; a free key opens every read tool.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables job search and scraping across multiple job boards (LinkedIn, Indeed, Glassdoor, etc.) with advanced filtering, directly from Claude Desktop or other MCP clients.6MIT
- AlicenseNot gradedqualityBmaintenanceSearches LinkedIn for job posts, filters out non-vacancies and out-of-market roles, and provides a local dashboard to triage and rate the remaining openings.1ISC
- AlicenseNot gradedqualityBmaintenanceEnables natural-language job search and aggregation from multiple recruitment websites with zero configuration, providing filtered results and standardized output for AI assistants.51 npmISC
- FlicenseNot gradedqualityBmaintenanceEnables automated job searching from multiple boards, filtering matches against saved criteria, deduplicating seen postings, and tracking application statuses. Runs locally and integrates with Claude Desktop for natural-language queries and updates.-