Landed

io.github.landedjobsPublished by GitHub account landedjobsv0.1.1Updated Nov 2, 2026

Search AI-native jobs, inspect application forms, and fetch free interview-prep resources.

VerifiedStreamable HTTPWeb executableProductivity & WorkflowKnowledge & Memory

Overview

AI-generated overview

Landed is a hosted MCP server that lets an assistant search AI-native job listings, inspect application forms, and fetch free interview-prep resources.

What you can do
  • Search a live corpus of AI-native roles and get a ranked, fit-scored shortlist from structured criteria such as role, skills, seniority, pay, work mode and location eligibility
  • Retrieve a specific job's application form, grouped into standard, screening and EEO fields, so answers can be drafted before applying
  • Fetch free curated learning material: interview-prep repos, portfolio-project catalogs and role roadmaps, filterable by topic, role or category
  • Use built-in prompts that guide a search-and-shortlist flow, application preparation, and study planning for a role
When to use it
Useful when someone is job-hunting for AI-related roles and wants an assistant to search listings, prepare application answers, or assemble interview study material without copying job boards into chat.
Requirements
Remote Streamable HTTP endpoint; no install or local runtime needed. Works anonymously with a shared daily free budget; an optional Authorization Bearer token (minted in Landed settings) gives unlimited, personalized search. Self-hosting requires Node.js 20 or later, pnpm, and the LANDED_API_BASE and LANDED_INTERNAL_SECRET variables.
Before you install
Anonymous use is metered by IP plus an issued anonymous token and resets daily, so heavy searching hits a cap. An Authorization Bearer token is a credential and should be kept private. Search requests and any profile or brief data are sent to Landed's hosted API. The form tool only returns fields for preparation; the assistant does not submit applications.

Installation

In SourceWeft

  1. Open Landed in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.landedjobs%2Flanded/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "landed": {
      "type": "http",
      "url": "https://mcp.landed.jobs/mcp"
    }
  }
}

README

[Landed]

[Landed MCP Server]

[License: MIT] [Model Context Protocol] [smithery badge] [Works with Claude] [Works with Cursor]

Search AI-native jobs, prepare applications, and study for interviews — from any MCP client. A public Model Context Protocol server giving Claude, Cursor, VS Code, and any MCP-capable agent live access to Landed's ranked, fit-scored job corpus.

Maintained by Landed — daily AI-native job matches, agent help with every application, and mock-interview prep.

What is this?

Landed MCP connects your AI assistant to a curated, continuously-updated corpus of AI-native roles (AI Engineer, ML Engineer, RAG Engineer, AI PM, GTM Engineer, and more). Instead of copy-pasting job boards into a chat, your agent can:

  • 🔎 Search jobs — ranked and fit-scored against a structured brief (role, skills, seniority, remote, compensation, industries…), or from a plain-English description.
  • 📝 Prepare applications — pull a job's real application form, grouped into standard / screening / EEO fields, so the agent can auto-fill and draft answers before you apply.
  • 🎓 Study for interviews — fetch free, curated interview-prep, portfolio, and roadmap resources.

It speaks Streamable HTTP and works with any MCP client. Use the hosted server in seconds, or self-host this repo against your own Landed API.

Free to start. Anonymous callers get a shared free budget — no signup, no key. Add an API token for unlimited, personalized results.

Quick start (hosted)

The hosted server lives at:

https://mcp.landed.jobs/mcp

Pick your client below. Everything works anonymously out of the box — just omit the Authorization header. Add Authorization: Bearer lnd_live_… (mint one at Landed → Settings → API tokens) for unlimited, brief-personalized search.

Claude Code

The one-liner (CLI):

bash
# Anonymous (free tier)claude mcp add --transport http landed-jobs https://mcp.landed.jobs/mcp
# Authenticated (unlimited, personalized)claude mcp add --transport http landed-jobs https://mcp.landed.jobs/mcp \  --header "Authorization: Bearer lnd_live_your_token_here"

Then in a session: /mcp to confirm it's connected, and try the find_jobs prompt.

Claude Desktop

Open Settings → Developer → Edit Config (this opens claude_desktop_config.json), then add:

jsonc
{  "mcpServers": {    "landed-jobs": {      "command": "npx",      "args": [        "-y", "mcp-remote", "https://mcp.landed.jobs/mcp",        "--header", "Authorization: Bearer lnd_live_your_token_here"      ]    }  }}

Restart Claude Desktop. Drop the --header line for the free anonymous tier.

Claude Desktop bridges remote HTTP servers through mcp-remote. If your build has native Custom Connectors (Settings → Connectors → Add custom connector), you can instead paste https://mcp.landed.jobs/mcp directly.

Cursor

Create .cursor/mcp.json in your project (or ~/.cursor/mcp.json globally):

jsonc
{  "mcpServers": {    "landed-jobs": {      "url": "https://mcp.landed.jobs/mcp",      "headers": { "Authorization": "Bearer lnd_live_your_token_here" }    }  }}

Then enable landed-jobs under Settings → MCP. Omit headers for the free tier.

VS Code (GitHub Copilot / Agent Mode)

Create .vscode/mcp.json:

jsonc
{  "servers": {    "landed-jobs": {      "type": "http",      "url": "https://mcp.landed.jobs/mcp",      "headers": { "Authorization": "Bearer lnd_live_your_token_here" }    }  }}

Open the Chat view → Agent mode → the tools appear under the 🔧 picker.

Windsurf

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

jsonc
{  "mcpServers": {    "landed-jobs": {      "serverUrl": "https://mcp.landed.jobs/mcp",      "headers": { "Authorization": "Bearer lnd_live_your_token_here" }    }  }}

Cline (VS Code extension)

Open Cline → MCP Servers → Configure, or edit cline_mcp_settings.json:

jsonc
{  "mcpServers": {    "landed-jobs": {      "type": "streamableHttp",      "url": "https://mcp.landed.jobs/mcp",      "headers": { "Authorization": "Bearer lnd_live_your_token_here" }    }  }}

Gemini CLI

Edit ~/.gemini/settings.json (or .gemini/settings.json in your project):

jsonc
{  "mcpServers": {    "landed-jobs": {      "httpUrl": "https://mcp.landed.jobs/mcp",      "headers": { "Authorization": "Bearer lnd_live_your_token_here" }    }  }}

Restart gemini and run /mcp to see the tools. Omit headers for the free tier.

Any other MCP client

Point it at https://mcp.landed.jobs/mcp using the Streamable HTTP transport. Pass Authorization: Bearer <token> if you have one. Quick sanity check from a terminal:

bash
curl -s -X POST https://mcp.landed.jobs/mcp \  -H 'content-type: application/json' \  -H 'accept: application/json, text/event-stream' \  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Registries

Landed is listed on the Official MCP Registry as io.github.landedjobs/landed, and on Smithery as landedjobs/landed. Clients that read either registry can discover and install it without any manual configuration.

Tools

ToolWhat it doesAnonymous cost
search_jobsRanked, fit-scored jobs. Supports physical city/country labels plus canonical remote-eligibility country/region codes; free text is parsed server-side.1 unit / job returned
get_job_formApplication form for a jobId, grouped standard / screening / eeo for answer prep.free
get_learning_contentCurated interview-prep, portfolio, and roadmap resources.free

Prompts (guided workflows)

MCP prompts are reusable, user-invocable skills that teach the agent how to chain the tools and present results as a clean shortlist — never raw JSON. In most clients they show up as slash-commands.

PromptArgsWhat it guides
find_jobsdescribe?Search, then present a ranked, fit-scored shortlist + next steps.
prepare_applicationjobIdFetch the form; auto-fill standard, draft screening, leave EEO to the user.
prep_for_rolerole?Pull learning resources for a role and suggest a study order.

The server also ships always-on instructions (tool overview, presentation rules, freemium behavior) that compliant clients load automatically.

Location parameters

Location eligibility is structured rather than keyword-matched:

  • locations: physical cities/countries, with country included for ambiguous cities, e.g. ["Bengaluru, India"]
  • countryCodes: ISO alpha-2 remote/base eligibility, e.g. ["IN"]
  • regionCodes: apac, emea, or americas
  • workAuthorizationCountryCodes: ISO alpha-2 work-authorization countries
  • remote: work mode (remote, hybrid, or onsite)

The hosted API resolves human city labels to stable place identities. Callers must not invent place IDs. The legacy regions field remains accepted for compatibility.

Auth & pricing

TierHowWhat you get
AnonymousNo headerA free budget of job-units that resets every day at 00:00 UTC. Metered by a hybrid of your IP and an issued X-Landed-Anon token (echoed on every response — resend it to keep your budget across sessions).
AuthenticatedAuthorization: Bearer lnd_live_…Unlimited search, personalized to your saved brief + profile. Mint a token at Landed → Settings → API tokens.

Every result carries a freemium block so your agent can see how much budget is left and how to lift the cap.

Architecture

This repository is a thin, self-hostable proxy. It speaks MCP and forwards to the hosted Landed API — it holds no database, no ranking engine, and no job data.

   MCP client                 landed-mcp (this repo)              Landed API ┌─────────────┐   HTTP    ┌────────────────────────┐  HTTPS   ┌────────────────────────┐ │ Claude /    │ ───────▶  │ • MCP protocol + tools │ ──────▶  │ • search engine        │ │ Cursor /    │  /mcp     │ • forwards caller creds│          │ • job corpus + forms   │ │ VS Code …   │ ◀───────  │ • local learning list  │ ◀──────  │ • auth · freemium meter│ └─────────────┘           └────────────────────────┘          └────────────────────────┘

The proxy resolves nothing itself: it forwards the caller's API token (or an anonymous id) to the Landed API, which validates it, runs the search, meters usage, and returns results plus a freemium block the proxy relays verbatim. The get_learning_content catalog is static and lives in this repo (src/mcp/catalog/learning.ts) — that tool works with no backend at all.

Self-host

Run your own proxy against the Landed API (or your own deployment of it).

Prerequisites

  • Node.js ≥ 20
  • pnpm (npm i -g pnpm)
  • A Landed API base URL and its shared internal secret

Run

bash
git clone [email protected]:landedjobs/landed-mcp.gitcd landed-mcppnpm installcp .env.example .env       # then fill in the values belowpnpm dev                   # hot-reload dev server# → [mcp] listening on :8090 — POST /mcp → https://api.landed.jobs/api/v1

For production: pnpm start.

Stdio and Docker

For clients that start the server as a process, pnpm start:stdio speaks MCP over stdio instead of HTTP. Set LANDED_API_TOKEN to use your own API token; without it you get the anonymous free budget.

bash
docker build -t landed-mcp .docker run -i --rm landed-mcp

The image runs the stdio server against the hosted API.

Environment variables

VariableRequiredDefaultDescription
LANDED_API_BASE✓http://localhost:8000/api/v1Hosted Landed API base, including the /api/v1 prefix.
LANDED_INTERNAL_SECRET✓—Shared secret authenticating this proxy to the API (must match the server's INTERNAL_SERVICE_SECRET).
PORT8090HTTP port to listen on.
CORS_ORIGINS*Comma-separated allowlist of origins, or *.
RATE_LIMIT_PER_MIN60Per-IP first-line request cap. The API's freemium meter is the real economic cap.

Endpoints

MethodPathPurpose
POST/mcpMCP Streamable HTTP endpoint (stateless).
GET/healthzLiveness probe ({ "ok": true }).

Development

bash
pnpm dev           # watch + reloadpnpm check-types   # tsc --noEmitpnpm test          # deterministic input-contract testspnpm start         # run once

The repository includes official MCP Registry metadata in server.json. It describes the public Streamable HTTP endpoint but does not imply that the server has been submitted to or accepted by any external registry.

Project layout

src/├── index.ts                 # bootstrap: start the HTTP server├── config/                  # env → typed config├── http/                    # express shell + per-IP rate limiter├── services/api-client.ts   # typed fetch client → Landed API├── types.ts                 # the API response contract (owned here)└── mcp/    ├── server.ts            # instructions + tool/prompt registration    ├── prompts.ts           # find_jobs / prepare_application / prep_for_role    ├── catalog/learning.ts  # static, public learning resources    └── tools/               # search_jobs · get_job_form · get_learning_content

Stack: TypeScript · Express · @modelcontextprotocol/sdk · Zod. No database, no build step (runs on tsx).

Contributing

Issues and PRs welcome — bug fixes, new client setup guides, and learning-catalog additions especially. Please run pnpm check-types and pnpm test before opening a PR. For private vulnerability reports, follow SECURITY.md.

License

MIT © Landed

Source: README.md at commit d5e0340

Tools

3

search_jobs

Search jobs

Search Landed's live job corpus for AI-native roles and get a ranked, fit-scored shortlist. Fill the structured fields (role, skills, work mode, physical locations, remote-eligibility countries/regions, seniority, comp, industries…) from the user's request — they drive the ranking. Physical locations are resolved to stable places; use ISO country codes and canonical region codes when known. You may also pass a free-text "query"; it's parsed into the same filters and used as a semantic nudge. Free tier: up to a shared budget of jobs for anonymous callers (each returned job counts). Authenticated callers (Authorization: Bearer <API token>) get unlimited, brief-personalized results.

ParametersroleavoidlimitqueryremoteskillsminCompregionscurrencylocationsseniorityindustries+4 more

get_job_form

Get job application form

Get the application form for a job (by the jobId returned from search_jobs), so you can prepare answers before the user applies. Fields are grouped: "standard" (auto-fillable from a candidate profile via mapsTo), "screening" (free-text questions to draft from the résumé/experience), and "eeo" (leave to the user). Always free — a job's form is only reachable once you've already found the job via search_jobs.

ParametersjobIdrequired

get_learning_content

Get learning content

Get Landed's free learning content to help the user prepare — curated interview-prep repos (real questions, company guides, worked system designs), portfolio-project catalogs, and role roadmaps from the landedjobs GitHub org. Filter by topic, role, and/or category. Always free, for any caller.

Parametersroletopiccategory

Version history

1
  1. v0.1.1LatestSep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts