# Worklittle Jobs MCP server

Search over 4 million jobs with visa, salary and distance filters, swipe to apply from your AI app, and save roles to a Worklittle account.

## At a glance

Worklittle Jobs is an MCP server in the Productivity category. It is hosted remotely and connects over HTTP, and declares no required credentials. It exposes 23 tools, including search_jobs, search_companies and get_job_details. It scores B (73/100) on the MCP Skills Hub health score as of Oct 28, 2026.

## Install

### How to install Worklittle Jobs in Claude Code

1. Add the server

```bash
claude mcp add --transport http jobs https://mcp.worklittle.com/
```

2. Verify it's connected

```bash
claude mcp list
```

3. Sharing it with your team?

   Add `--scope project` to write it to .mcp.json in the repository root, which you can commit (with the secrets left as environment variables).

4. Use it in a session

   Ask Claude to use the tools this server exposes (e.g. search_jobs, search_companies, get_job_details). It discovers them automatically.

### How to install Worklittle Jobs in Claude Desktop

1. Open your MCP config

   macOS: ~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

2. Add this server

```json
{
  "mcpServers": {
    "jobs": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.worklittle.com/"
      ]
    }
  }
}
```

3. Why the wrapper?

   This is a remote (HTTP) server and Claude Desktop only launches local processes, so mcp-remote proxies the connection. It will open a browser window if the server needs OAuth.

4. Restart Claude Desktop

   The tools appear under the 🔌 menu once the app reloads.

### How to install Worklittle Jobs in Cursor

1. Create / edit .cursor/mcp.json in your project

```json
{
  "mcpServers": {
    "jobs": {
      "url": "https://mcp.worklittle.com/"
    }
  }
}
```

2. Enable it

   Cursor Settings → MCP → toggle the server on. Tools become available to the Composer/Agent.

### How to install Worklittle Jobs in Codex CLI

1. Add to ~/.codex/config.toml

```toml
[mcp_servers.jobs]
command = "npx"
args = ["-y", "mcp-remote", "https://mcp.worklittle.com/"]
```

2. Why the wrapper?

   Codex runs MCP servers as local processes, so mcp-remote bridges this HTTP endpoint to stdio.

3. Run Codex

   Codex loads MCP servers from config.toml on startup and exposes their tools to the agent.

### How to install Worklittle Jobs in Windsurf

1. Edit ~/.codeium/windsurf/mcp_config.json

```json
{
  "mcpServers": {
    "jobs": {
      "serverUrl": "https://mcp.worklittle.com/"
    }
  }
}
```

2. Reload

   Windsurf → Cascade → refresh MCP servers. Cascade can now call the tools.

### How to install Worklittle Jobs in Cline

1. Open Cline → MCP Servers → Configure

   Adds to cline_mcp_settings.json.

2. Add the server

```json
{
  "mcpServers": {
    "jobs": {
      "type": "streamableHttp",
      "url": "https://mcp.worklittle.com/"
    }
  }
}
```

### How to install Worklittle Jobs in VS Code

1. Create .vscode/mcp.json

```json
{
  "servers": {
    "jobs": {
      "type": "http",
      "url": "https://mcp.worklittle.com/"
    }
  }
}
```

2. Start it

   VS Code shows a ▶ Start action above the server entry. Agent mode (Copilot Chat) can then use the tools.

## Tools

- `search_jobs` — Jobs — Opens the Worklittle jobs MAP for a place and an optional role. This is a map query, not a list of jobs: the map recenters on the place and shows jobs there, so send the place and the role as SEPARATE fields. Never write 'product manager in San Francisco' as one query. PLACE: always pass near_lat + near_lng (the city's coordinates, which you know) and location as the display name (e.g. 'San
- `search_companies` — Jobs — Search the Worklittle market company index by name or slug (ranked typeahead). Returns id, name, slug, logo_url, and enrichment fields for employers with open jobs. Use when the user names an employer and you need a real slug/id for search_jobs company= filters, job alerts, or automations. If zero hits, try alternate spellings or related employer names from further search_companies calls — 
- `get_job_details` — Jobs — Fetch detailed information about a specific job, including full responsibilities, qualifications, and company details. Pass job_id from search_jobs when you have one. If the user asks for full details of a role without an id (e.g. the first software engineer job in Austin), pass query and optional location instead — the tool loads the first matching live listing.
- `get_market_overview` — Jobs — Returns aggregate job-market statistics from Worklittle. Call with no args for the full indexed market (counts, workplace mix, top hiring companies). When the user names a role and/or city (e.g. product managers in San Francisco), pass query and location. The filtered slice includes match count, top companies in the sample, and salary signals from listings that publish pay.
- `track_applied_job` — Jobs — Add a job to the user's Applied or Saved list, or change its status, so they can find it later.
- `get_my_profile` — Jobs — Get the user's Worklittle profile (name, location, contact details and job preferences). If they have not linked their account it returns connected false; use get_my_resume or apply_for_job to sign them in.
- `list_recent_chats` — Jobs — List the user's recent Worklittle chats (title and status) for the app sidebar.
- `mint_mcp_ui_embed_session` — Jobs — Create a sign-in link so the Worklittle app can open the user's chats on worklittle.com.
- `logout_connected_account` — Jobs — Sign the user out of Worklittle in this app.
- `upload_my_resume` — Jobs — Save the resume the user attached in the chat (PDF, Word, text or image) as the main resume on their Worklittle profile so it can be used to apply. It replaces the current main resume; other saved resumes (an account keeps up to 5) stay. Pass the attached file as resume_file.
- `get_my_resume` — Jobs — Get the user's main resume: its status (ready, processing or missing) and, when ready, the resume text and profile details read from it. Use it to tailor advice or an application to the user's real experience.
- `delete_my_resume` — Jobs — Delete the user's main resume from their profile. Other saved resumes stay.
- `update_my_profile` — Jobs — Update the user's Worklittle profile, such as name, location, phone, links or the kind of job they want. Only send the fields to change.
- `apply_for_job` — Jobs — Apply to a job for the user: Worklittle fills out and submits the application in a browser. Pass job_id from search_jobs. For a Worklittle-hosted posting also include name, email and resume. It submits by default; pass auto_submit false when the user wants to review first, then show them the answers from check_application_status and send it with submit_application only after they say so.
- `check_application_status` — Jobs — Check an application Worklittle is filling out: its status, which form fields are filled, and a live view link. Only the status completed means it was submitted.
- `submit_application` — Jobs — Send an application that stopped for review (apply_for_job with auto_submit false, status awaiting_submit). Call it only after the user has seen the answers from check_application_status and said to send it.
- `stop_application` — Jobs — Stop an application that Worklittle is filling out for the user. This cancels the application in progress and it cannot be resumed; the user would have to start it again. Needs the session_id from apply_for_job or list_active_applications.
- `steer_application` — Jobs — Change what an application in progress fills in, without stopping it. Use when the user says something about an application Worklittle is filling right now ("say my notice period is one month", "my friend Ana Ruiz referred me", "I need visa sponsorship for the US", "make that answer shorter"). Pass their wish as plain instructions with their exact facts; never add facts. Works while the app
- `save_about_me` — Jobs — Save standing facts about the user that Worklittle's Apply with AI uses on every future application: work authorization and visa sponsorship by country, relocation, notice period, desired salary, languages, qualifications, who referred them, or other standing answers they ask applications to use. Stored as the 'More about you' text in their Settings. Pass the complete text to keep (read get
- `list_active_applications` — Jobs — List the user's applications that Worklittle is filling out right now (queued, running, or waiting on the user), with job_id and session_id. Use it to find which one to stop or check.
- `list_applications` — Jobs — List applications: pending ones (matched by auto-apply, waiting for approval, running, or waiting on the user) and finished ones (completed = submitted, failed, stopped). Check it before applying so the same job is never applied to twice. Filter with status (pending, applied, ...), job_id or applicant_id.
- `get_apply_settings` — Jobs — Get the user's apply settings: auto_apply (Worklittle applies to matching jobs on its own), auto_submit (submit without a review stop) and tailor_resume (tailor the resume to each job).
- `update_apply_settings` — Jobs — Turn auto_apply, auto_submit or tailor_resume on or off. Only send the settings to change. Turning auto_apply on needs Instant or a card on file.

Source repository: https://github.com/worklittle/jobs-mcp

---

Source: https://mcp-skills-hub.vercel.app/mcps/io-github-worklittle-jobs · MCP Skills Hub · data as of 2026-10-28T12:31:05Z