Ask your coding assistant for "remote TypeScript jobs posted this week" and it answers with the jobs, straight from employer career sites, and with the exact Jobven API call that found them. Paste that call into your code and the integration is written. The Jobven MCP server works with Claude Code, Cursor, VS Code and Codex, uses the API key you already have, and is metered like the API: a search that returns 10 jobs counts 10 jobs.

I built it because the slow part of integrating a jobs API is rarely the HTTP call. It is finding out which filters give you the jobs you want, what the fields look like on real postings, and whether the data covers your market at all. That exploring is easier in a conversation than in a terminal, and the conversation should end with code you can keep.

Connect it in a minute

You need a Jobven API key (a free one takes a minute). Put it in an environment variable so it never lands in a config file you might commit:

export JOBVEN_API_KEY="your-api-key"

Then add the server to your assistant. In Claude Code, a .mcp.json at the root of your project:

{
  "mcpServers": {
    "jobven": {
      "type": "http",
      "url": "https://api.jobven.com/mcp",
      "headers": {
        "X-API-Key": "${JOBVEN_API_KEY}"
      }
    }
  }
}

Cursor, VS Code and Codex take the same URL and header in their own config formats. All four are on the MCP server docs page, ready to copy.

From a question to working code

The assistant gets five tools. Four of them read Jobven data: search_jobs takes every filter of GET /v1/public/jobs (title words, skills, remote type, country, city, salary, posting dates and the rest), get_job returns one job with its full description, and search_companies and get_company cover the employers.

Ask for a count as well and search_jobs adds total, every job matching the filters rather than just the page, which answers "how much of this is there" before you write anything.

Each of those four returns a request alongside its results:

{
  "method": "GET",
  "url": "https://api.jobven.com/v1/public/jobs?q=typescript&remoteType=remote&limit=10&descriptionFormat=plain",
  "curl": "curl -H \"x-api-key: $JOBVEN_API_KEY\" 'https://api.jobven.com/v1/public/jobs?q=typescript&remoteType=remote&limit=10&descriptionFormat=plain'"
}

That is the call the tool made, with your key replaced by $JOBVEN_API_KEY. Once a search returns the jobs you want, ask the assistant to turn it into code, and it starts from a request that is known to work:

const params = new URLSearchParams({
  q: 'typescript',
  remoteType: 'remote',
  limit: '100',
})

const res = await fetch(`https://api.jobven.com/v1/public/jobs?${params}`, {
  headers: { 'X-API-Key': process.env.JOBVEN_API_KEY! },
})
const { data, meta } = await res.json()
// meta.nextCursor fetches the next page with the same filters

Two differences between a chat search and your code are deliberate. In chat, search_jobs returns 10 jobs by default and at most 25, each with a plain-text excerpt of its description, so a page stays around 2,800 tokens and leaves room in the assistant's context for the rest of your work. In code you choose: full descriptions as HTML, plain text, markdown or all three (see description formats), and up to 100 jobs a page on Growth and above.

Test a webhook receiver without waiting for a job

If you take jobs by webhook, the hard part is testing the receiver: you need a delivery with a valid signature, and real ones arrive on the employers' schedule, whenever a job changes.

webhook_example hands the assistant a delivery for job.created, job.updated, job.closed or job.deleted: the raw body and every header exactly as your endpoint receives them, signed with an example secret, plus the signature verifier from the webhook docs in TypeScript, Python or Go. The verifier accepts the sample for five minutes, so the assistant can write your receiver, POST the sample to it on localhost, and show you the check passing before a single real delivery arrives. When it goes live, swap the example secret for your subscription's signing secret.

webhook_example makes no API call, so it needs no key and counts nothing.

What it costs

The same as the API, because it is the API. Every search and lookup goes through the same key check, rate limit and monthly allowance as a request from your code, and shows up in your usage the same way.

• search_jobs and get_job: each job returned counts one toward your monthly allowance. A default search counts 10; an empty one counts nothing.
• search_companies and get_company: free, as they are through the API.
• webhook_example: free, and works without a key.

The free plan's 300 jobs a month is 30 default searches. When the allowance runs out, the tool returns the date it resets, so the assistant can tell you.

Who it helps

• Developers building a job board or a jobs feature get from "what filters do I need" to a working request without reading the whole reference first.
• Data and analytics teams can check coverage for a market (a country, a skill, a salary band) before committing to a pipeline.
• Founders evaluating job data providers can ask the questions they care about, such as how many remote roles mention a given skill, and see real postings before talking to anyone.
• People building AI agents get a tool their agent can call, with results it can quote back.
• Teams on webhooks can test signature checking end to end on a laptop.

What the assistant sees

Every tool is read-only: none of them create, change or delete anything on your account. Job titles and descriptions are the employers' own words, so the tools return them as plain data, with HTML removed and the invisible characters sometimes used to hide text from a human reader stripped out. Links are kept only when they are ordinary web addresses. Your API key never appears in a tool result.

Try it

Add the server, then ask your assistant for the jobs you have in mind, in your own words. When a search looks right, ask for the code. The MCP server docs have the configs for all four assistants and the details of each tool.