# Remote Jobs MCP Server (`mrbridge/remote-jobs-mcp`) Actor

Remote jobs MCP server for Claude, ChatGPT, Cursor and any MCP client. Search remote openings from public job boards such as Jobicy and Arbeitnow by skill, location, seniority or salary, check whether saved jobs are still open, and read advertised salary ranges and hiring trends.

- **URL**: https://apify.com/mrbridge/remote-jobs-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Jobs
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 💼 Remote Jobs MCP Server

This MCP server lets Claude, ChatGPT, Cursor, VS Code or any MCP client search remote job openings from several public job boards in one format. It exposes 8 read-only tools: a job search, a single-job lookup, a status check for saved jobs, advertised salary ranges, a hiring snapshot and the filter lists, plus the `search` and `fetch` pair that ChatGPT uses for citations.

Ask Claude "which senior Python jobs open to candidates in Europe were posted this week, and what do they pay?" and it calls `jobs_search`, then `jobs_salary_insights`. You get the matching jobs with company, advertised salary and a link to each listing, then the median and quartiles of the salaries those listings show. No job board tabs to juggle.

### Quick start

1. Copy your Apify API token from [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations).
2. Point your MCP client at `https://mrbridge--remote-jobs-mcp.apify.actor/mcp` with that token, as a Bearer header or as `?token=` in claude.ai and ChatGPT ([Connect](#connect) has every recipe).
3. Ask in plain language.

### What this server exposes

This server reads remote job listings from three job boards: the public Jobicy Remote Jobs API, which covers jobs published on Jobicy in the last 7 days, the Arbeitnow Job Board API, whose newest remote jobs are added with Arbeitnow's permission, and the public Remotive Remote Jobs API, whose active jobs appear 24 hours after their publication on Remotive. It has 6 read-only tools: a job search by keyword, candidate location, category, employment type, seniority, company, minimum yearly salary, recency and job board, a lookup of one job with its current status, a status check for up to 100 saved jobs, advertised salary ranges, a hiring overview (top companies and the mix of categories, types, levels and locations), and the list of location and category values, plus the `search` and `fetch` pair for ChatGPT. Every job comes in one normalised schema with its source and its link on that job board, and full descriptions stay there. It needs no API key and no account.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `jobs_search` | Search remote jobs | `tool-read` |
| `jobs_get_job` | Get one remote job | `tool-read` |
| `jobs_check_status` | Check whether jobs are still open | `tool-read` |
| `jobs_salary_insights` | Remote job salary ranges | `tool-action` |
| `jobs_market_snapshot` | Remote hiring snapshot | `tool-action` |
| `jobs_list_filters` | List location and category filters | `tool-read` |
| `search` | Search | `tool-read` |
| `fetch` | Fetch | `tool-read` |

#### `jobs_search`: Search remote jobs

Use this when the user wants remote job openings: by keyword (skill, role, technology), by where candidates may live, by category, employment type, seniority, company, minimum yearly salary or recency. Covers jobs published on Jobicy in the last 7 days, the newest remote jobs of Arbeitnow and the active jobs of Remotive (shown 24 hours after publication), merged newest first. Do not use for salary statistics (jobs_salary_insights), hiring counts and top companies (jobs_market_snapshot), the open or closed status of saved jobs (jobs_check_status), or the filter values (jobs_list_filters). Parameters: `keyword` (string, e.g. "python"), `location` (slug or name, e.g. "europe"), `category` (slug or name, e.g. "engineering"), `job_type` (e.g. "full-time"), `level` (e.g. "senior"), `company` (e.g. "Acme"), `min_salary` (yearly, e.g. 100000) with `salary_currency` (default "USD"), `posted_within_days` (1 to 7), `source` ("all", "jobicy", "arbeitnow" or "remotive"), `limit` (1 to 50, default 10), `offset`, `response_format` ("detailed" adds a short excerpt and the logo, at most 25 jobs). Each job has an id, title, company, location, types, level, categories, salary as advertised, publication time, its source and its link on that job board. Descriptions are not returned: follow the link. `sources` says which job boards answered. `next_call` reads the first job with jobs_get_job.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `keyword` | string | no | `"python"` |
| `location` | string | no | `"europe"` |
| `category` | string | no | `"engineering"` |
| `job_type` | "full-time" or "part-time" or "contract" or "freelance" or "internship" or "temporary" | no | `"full-time"` |
| `level` | "junior" or "mid" or "senior" or "lead" or "manager" | no | `"senior"` |
| `company` | string | no | `"Acme"` |
| `min_salary` | number | no | `100000` |
| `salary_currency` | string | no | `"USD"` |
| `posted_within_days` | integer | no | `3` |
| `source` | "all" or "jobicy" or "arbeitnow" or "remotive" | no | `"all"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ jobs[], pagination, filters, coverage, notices[], next_call, sources[], attribution, attributions[] }`. Upstream: Jobicy, Arbeitnow, Remotive. Cache: hourly (1 hour). Read-only.

#### `jobs_get_job`: Get one remote job

Use this when the user wants one job found by jobs_search: its fields, a short excerpt, its link on the job board and whether it is still open. Do not use for searching (jobs_search) or for checking many saved jobs at once (jobs_check_status). Parameters: `job_id` (required, an id from jobs_search such as "jobicy:4401008", "arbeitnow:<slug>" or "remotive:<id>", a bare Jobicy number, or a Jobicy, Arbeitnow or Remotive job link), and for a Jobicy job the `keyword`, `location` and `category` of the search that returned it (jobs_search gives them in next_call), because the job is read back from that search. Without them only the 1,000 newest Jobicy jobs are searched. `response_format` "detailed" adds the logo and cache information. The full description stays on the job board page.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `job_id` | string | yes | `"jobicy:4401008"` |
| `keyword` | string | no | `"python"` |
| `location` | string | no | `"europe"` |
| `category` | string | no | `"engineering"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ job, status, notices[], attribution }`. Upstream: Jobicy, Arbeitnow, Remotive. Cache: hourly (1 hour). Read-only.

#### `jobs_check_status`: Check whether jobs are still open

Use this when the user wants to know whether saved or earlier found jobs are still open, up to 100 at once, Jobicy jobs older than the 7-day feed included. Do not use for finding jobs (jobs_search) or reading one job's fields (jobs_get_job). Parameter: `job_ids` (array of 1 to 100 ids from jobs_search such as "jobicy:4401008", "arbeitnow:<slug>" or "remotive:<id>", bare Jobicy numbers or job links). Each job comes back as "active" (open for applications), "closed" (expired, filled or past its expiry date) or "unknown" (missing, deleted or not public, not a confirmed closure), with a summary count. Jobicy reports its own status. Arbeitnow and Remotive publish none, so their jobs are "active" while they are in the current feed of the board and "unknown" otherwise. When no job is confirmed, the answer is NOT_FOUND. This is the job board listing state, not a check of the employer's own site.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `job_ids` | array of values | yes | `["jobicy:4401008","jobicy:4401007"]` |

Returns `{ jobs[], summary, checked_at, attribution, attributions[] }`. Upstream: Jobicy, Arbeitnow, Remotive. Cache: intraday (5 minutes). Read-only.

#### `jobs_salary_insights`: Remote job salary ranges

Use this when the user asks what remote jobs pay: salary ranges, median and quartiles for a skill, role, category, location, employment type or seniority, from the salaries advertised in Jobicy listings of the last 7 days and in active Remotive listings. Do not use for a list of openings (jobs_search) or hiring counts (jobs_market_snapshot), and do not read it as a market survey: it covers advertised ranges of recent remote listings only. Parameters: `keyword` (e.g. "data scientist"), `location` (e.g. "usa"), `category` (e.g. "data-science"), `job_type` (e.g. "full-time"), `level` (e.g. "senior"), `salary_currency` (optional, keeps one currency, e.g. "EUR"), `response_format` ("detailed" adds the median per level and five top-paying jobs instead of three). Statistics are computed per currency and pay period on the midpoint of each advertised range, never converted. The answer says how many matching jobs list a salary and how much of the 7-day window was read. Remotive salary texts count only when their amounts, currency and period are clear. Arbeitnow listings carry no salary, so they are not used here.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `keyword` | string | no | `"python"` |
| `location` | string | no | `"europe"` |
| `category` | string | no | `"engineering"` |
| `job_type` | "full-time" or "part-time" or "contract" or "freelance" or "internship" or "temporary" | no | `"full-time"` |
| `level` | "junior" or "mid" or "senior" or "lead" or "manager" | no | `"senior"` |
| `salary_currency` | string | no | `"USD"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ filters, jobs_matched, jobs_with_salary, salary_disclosure_rate, groups[], highest_paying[], coverage, notices[], sources[], attribution, attributions[] }`. Upstream: Jobicy, Remotive. Cache: hourly (1 hour). Read-only.

#### `jobs_market_snapshot`: Remote hiring snapshot

Use this when the user wants an overview of recent remote hiring for a keyword, location or category: how many jobs, which companies post the most, the split by category, employment type, seniority and location, and how many listings show a salary. Do not use for the openings themselves (jobs_search) or for salary figures (jobs_salary_insights). Parameters: `keyword` (e.g. "rust"), `location` (e.g. "europe"), `category` (e.g. "marketing"), `source` ("all", "jobicy", "arbeitnow" or "remotive"), `top` (entries per breakdown, 1 to 20, default 8), `response_format` ("detailed" adds jobs per publication day). Counts cover Jobicy listings of the last 7 days (at most the 1,000 newest per call), the newest remote Arbeitnow listings and the active Remotive listings, a job on several boards counted once. Arbeitnow tags and Remotive categories count as categories. The coverage block says whether the Jobicy window was read in full, `sources` which job boards answered. Shares are fractions of the jobs counted.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `keyword` | string | no | `"python"` |
| `location` | string | no | `"europe"` |
| `category` | string | no | `"engineering"` |
| `source` | "all" or "jobicy" or "arbeitnow" or "remotive" | no | `"all"` |
| `top` | integer | no | `8` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ filters, jobs, top_companies[], by_category[], by_job_type[], by_level[], by_location[], salary_disclosed, per_day[], coverage, notices[], sources[], attribution, attributions[] }`. Upstream: Jobicy, Arbeitnow, Remotive. Cache: hourly (1 hour). Read-only.

#### `jobs_list_filters`: List location and category filters

Use this when the user wants the locations (where candidates may live) or job categories the remote job search accepts, or when a location or category was refused as unknown. Do not use for finding jobs (jobs_search). The search tools already accept display names such as "United States" or "Software Engineering", so this call is only needed to browse or to settle an unknown value. Parameters: `kind` ("locations", "categories" or "both", default "both"), `query` (optional part of a name, slug or common alias, e.g. "united"), `response_format` ("detailed" adds cache information). Each value has a slug, the form the search tools send to Jobicy, and a display name.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `kind` | "locations" or "categories" or "both" | no | `"locations"` |
| `query` | string | no | `"united"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ locations, categories, notice, attribution }`. Upstream: Jobicy. Cache: daily (1 day). Read-only.

#### `search`: Search

Use this when ChatGPT needs remote job openings for a free-text query such as "senior rust jobs in europe": the useful words become a keyword, a location named in the query becomes a filter, and the 10 newest matching jobs of Jobicy (last 7 days), Arbeitnow (newest remote jobs) and Remotive (active jobs, 24 hours after publication) come back with their job board page as citation. Do not use for details, call fetch with a result id. Parameter `query` (string), e.g. "python developer europe".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"python developer europe"` |

Returns `{ results[], notices[] }`. Upstream: Jobicy, Arbeitnow, Remotive. Cache: hourly (1 hour). Read-only.

#### `fetch`: Fetch

Use this when ChatGPT needs one job returned by search: title, company, location, type, level, category, advertised salary, publication time, current status, a short excerpt and the job board link. Do not use for free-text queries (call search first). The full description stays on the job board page. Parameter `id` (an id from search, a Jobicy id, or a Jobicy, Arbeitnow or Remotive job link), e.g. "jobicy:4401008?keyword=python".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `id` | string | yes | `"jobicy:4401008?keyword=python"` |

Returns `{ id, title, text, url, metadata, notices[] }`. Upstream: Jobicy, Arbeitnow, Remotive. Cache: hourly (1 hour). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--remote-jobs-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http remote-jobs "https://mrbridge--remote-jobs-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "remote-jobs": {
      "type": "http",
      "url": "https://mrbridge--remote-jobs-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--remote-jobs-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add Remote Jobs MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Remote%20Jobs%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--remote-jobs-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--remote-jobs-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "remote_jobs",
  "server_url": "https://mrbridge--remote-jobs-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--remote-jobs-mcp.apify.actor/mcp",
      "name": "remote-jobs",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "remote-jobs"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/remote-jobs-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use this server

- **Several job boards, one answer.** Listings come back merged, newest first, with the same fields: title, company, location, type, level, category, salary, date, source and link. A job posted on two boards appears once.
- **Plain-language filters.** Location and category accept names such as "United Kingdom" or "web design", and a typo gets the closest valid values back instead of an empty list.
- **Salary figures you can check.** Salary ranges, with their median and quartiles, are computed from the salaries employers advertise, per currency and pay period, never converted. Each answer says how many listings showed a salary.
- **Still open or not?** Send up to 100 saved job ids and see which ones are active, closed or unknown, older Jobicy jobs included.
- **Credits handled.** Every job keeps its source and its link, and every answer carries the credit each job board asks for.
- **No key at the job boards.** You connect with your Apify token. You pay per successful call, plus the platform usage of your own server run.

### Pricing (Pay-per-Event)

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |
| `tool-action` | each successful call of a detailed or computed tool | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Three sources.** Listings come from Jobicy, Arbeitnow and Remotive. Each job carries its `source` ("Jobicy", "Arbeitnow" or "Remotive") and an id of the form `jobicy:<id>`, `arbeitnow:<slug>` or `remotive:<id>`. Answers merge the boards newest first and say in `sources` which boards answered. A job posted on several boards (same company and title) shows once: from Jobicy if it is there, else from Remotive. When a board fails, the answer holds the jobs of the others with a notice. `source` limits a search or a snapshot to one board.
- **7-day window, 3-hour delay.** The Jobicy feed holds jobs published in the last 7 days, shown 3 hours after publication. A job that leaves the feed can still be open: `jobs_check_status` reads the current status of any Jobicy id, older ones included. `unknown` there is not a confirmed closure.
- **Arbeitnow's newest remote jobs.** Only remote jobs are kept from Arbeitnow, read from one page of its feed at most once an hour. That page holds the newest listings of every kind, so it usually gives about a dozen remote jobs, and the `sources` block says how many. Arbeitnow publishes no job status, so `jobs_check_status` calls an Arbeitnow job `active` while it is in that feed and `unknown` once it is not. Arbeitnow gives the place where the employer is based, not the regions candidates may live in, and lists no Jobicy category, seniority or salary. So its jobs are left out of searches with a location, a category, a level or a minimum salary, and of the salary statistics, and the `sources` block says so. Its tags appear as categories.
- **Remotive's active jobs, a day late.** Remotive's public feed lists its active remote jobs 24 hours after they go up on Remotive, and every answer with Remotive jobs says so. This server reads the whole feed once a day and answers every question from that copy, so a new Remotive job can take up to two days to show up here. Remotive lists active jobs only: `jobs_check_status` calls a Remotive job `active` while it is in that copy and `unknown` once it is not. Remotive gives the regions candidates may live in as free text and has its own categories and no seniority. So its jobs are left out of searches with a location, a category or a level, and the `sources` block says so. Its salaries are free text too, read only when the amounts, one currency and one plausible pay period are clear. Those jobs count in a minimum salary filter and in the salary statistics. At most the 3,000 newest Remotive jobs are kept from one read, and the `sources` block says when older ones were left out.
- **At most 1,000 jobs per call.** A search reads up to 5 pages of 200 jobs, newest first. The `coverage` block says how many jobs were read and whether the whole 7-day window was covered. When it was not, add a keyword, a location or a category. Totals in a search are then lower bounds, and the answer says so. Pages of a search reach its first 1,000 matching jobs, all job boards together.
- **Excerpts, not descriptions.** Job descriptions belong to the employers. Answers carry a short excerpt (at most 400 characters, in `detailed` mode) and the listing link on Jobicy, Arbeitnow or Remotive, where the full description and the application are.
- **Contact details removed.** E-mail addresses, phone numbers and links in titles and excerpts are replaced by markers such as `[e-mail removed]` before anything is cached or returned.
- **Keywords.** Jobicy searches keywords of 3 to 50 bytes, and several words must all appear. For Arbeitnow, this server looks for every word in the title, company, tags and excerpt. A keyword of 1 or 2 characters ("AI", "Go") is matched as a whole word in job titles instead, with a notice. Locations and categories accept Jobicy slugs, display names or common names such as "United Kingdom" for Jobicy's "UK" (`jobs_list_filters` lists them), and an unknown value is refused with the closest names.
- **Filters done by this server.** Employment type, seniority, company, minimum salary and recency are applied by this server to the pages it reads. Seniority relies on the level Jobicy shows, and jobs without one are left out of a seniority filter. Jobicy has no lead level and lists lead and principal roles as senior or director, so for "lead" the job title decides among those. A minimum salary keeps yearly salaries in the chosen currency only.
- **Salaries and counts.** Salary statistics and hiring counts are computed by this server from advertised ranges. Salaries are grouped by currency and pay period and never converted, and many listings advertise no salary (`salary_disclosure_rate` shows how many do).
- **Reading a job back.** None of the APIs has a single-job endpoint, so `jobs_get_job` and `fetch` read a Jobicy job again from the search that found it, an Arbeitnow job from the cached Arbeitnow page and a Remotive job from the cached Remotive feed. Pass the `next_call` arguments of `jobs_search`, or the ids `search` returns, as they are.
- **Rate limits and freshness.** Jobicy publishes no number, only fair use and hourly synchronisation. This server keeps to 15 requests per minute and 300 per hour per instance, caches feed pages for an hour, filter lists for a day and statuses for 5 minutes. Arbeitnow allows 3 requests per minute: this server keeps to half of that, reads one page an hour for every question, and never retries a failed request. Remotive advises at most 4 reads a day and blocks more than 2 requests a minute: this server reads its feed once a day for each Apify account that runs it, never retries a failed read, and makes at most 1 request a minute and 3 in any 24 hours per instance. A busy period can answer `UPSTREAM_RATE_LIMITED`: retry a minute later.
- **Attribution.** Every answer has an `attribution` block for its main source, and the search, snapshot, salary and status answers an `attributions` list with one block per source shown, each crediting its job board with its link and terms page. The ChatGPT answers carry the same lines in `notices`. Keep the credit, the source and the link of each job when you show them.
- **Affiliation.** This server is not affiliated with or endorsed by Jobicy, Arbeitnow or Remotive.

### Data terms

The listings come from the public Jobicy Remote Jobs API, under the fair use terms at https://jobicy.com/jobs-rss-feed. Jobicy lets products, AI assistants included, use the listings without a separate agreement, on conditions that also bind you when you reuse what this server returns:

- **Credit Jobicy and keep the link.** Keep Jobicy as the original source and keep each job's Jobicy URL when you display it. Do not remove the attribution.
- **Do not present the listings as your own.** They are job postings published by the employers on Jobicy.
- **No spam or misleading job databases.** Do not use the listings to build spam networks, misleading job boards or services that harm employers or candidates.
- **Ask Jobicy for high volumes.** Jobicy asks high-volume commercial partners to contact it: https://jobicy.com/contact.

The Arbeitnow listings come from the public Arbeitnow Job Board API, which this server uses with Arbeitnow's written permission (October 2026) for remote jobs, read at most once an hour, within its rate limit. The conditions travel with the listings:

- **Name Arbeitnow and link back.** Each Arbeitnow job keeps its `source` and the link to its page on Arbeitnow (arbeitnow.com or a country site such as arbeitnow.ch). Show both with the job.
- **Do not present the listings as your own.** They are job postings published by the employers on Arbeitnow.

The Remotive listings come from the public Remotive Remote Jobs API, under the terms of its documentation at https://github.com/remotive-com/remote-jobs-api. Remotive was asked on 2026-10-06 whether a paid service such as this one may show them, and has not answered yet. They are shown in the meantime, and they will be withdrawn if Remotive says no or complains. The conditions of the API travel with the listings:

- **Name Remotive and link back.** Each Remotive job keeps its `source` and the link to its page on Remotive. Show both with the job.
- **Say that the jobs are delayed.** The public feed shows jobs 24 hours after their publication on Remotive.
- **Do not repost the listings to other job sites.** Remotive asks that its jobs are not submitted to third-party job sites, Jooble, Neuvoo, Google Jobs and LinkedIn Jobs included.
- **Do not trade the listings for sign-ups.** Remotive treats showing its jobs in exchange for sign-ups or e-mail addresses as a breach of its terms.

The fee for this server pays for the service (hosting, caching, normalisation, filters and the statistics it computes), not for a licence on the listings, which Jobicy, Arbeitnow and Remotive offer for free.

### Use cases

- **Job hunting with an assistant.** A candidate asks Claude for remote data engineering roles posted in the last 3 days, then gets a shortlist with a link to each listing.
- **Salary benchmarking.** Recruiters and career coaches check what recent remote listings advertise for a role and a seniority level before an offer or a negotiation.
- **Application tracking.** An agent re-checks a list of saved applications every morning and flags the listings that closed.
- **Hiring signals.** Analysts see which companies post the most remote roles in a category this week, and how seniority and employment types split.
- **Cited answers in ChatGPT.** Deep research links each job to its board page through the `search` and `fetch` pair.

### More work and productivity tools

- [AI task management with Todoist](https://apify.com/mrbridge/todoist-ai-assistant): Todoist tasks, projects and labels managed from Claude, with prioritization and a daily digest.

### FAQ

#### Which job boards does it cover?

Three public feeds today: Jobicy (jobs published in the last 7 days, shown 3 hours after publication), Arbeitnow (its newest remote jobs, read once an hour) and Remotive (its active remote jobs, shown 24 hours after publication and read once a day). It does not cover the whole remote job market. The `sources` block of each answer says which boards answered.

#### Does it return full job descriptions?

No. Descriptions belong to the employers. Answers carry a short excerpt of up to 400 characters and the link to the listing, where the full text and the application form are.

#### Why do some searches return Jobicy jobs only?

Arbeitnow and Remotive listings use neither Jobicy's regions nor its categories, and carry no seniority level, so they drop out when you filter on one of those. Arbeitnow shows no salary either, so a minimum salary leaves it out too. A keyword search without those filters shows every board.

#### What does a call cost?

Each successful tool call is one event, at the price shown on the [Pricing tab](https://apify.com/mrbridge/remote-jobs-mcp/pricing) for your Apify plan: `tool-action` for `jobs_salary_insights` and `jobs_market_snapshot`, `tool-read` for every other tool. Paid Apify plans get lower prices. On the free plan, a read costs $0.005 and an action $0.01, so 100 reads come to $0.50 in events. On top of that, your Apify account pays the platform usage of your own Standby run while the server is up, idle minutes included. Errors are never charged, and `maxTotalChargeUsd` caps what one run can spend.

#### Why is the first call slower?

The first call after a quiet period starts a new Standby run on your Apify account, which takes a few seconds. Then it answers quickly, and it shuts down after about 5 idle minutes.

#### Is this server affiliated with Jobicy, Arbeitnow or Remotive?

No. It reads their public APIs, Arbeitnow's with its permission, and credits each board in every answer. None of them endorses it.

#### Your feedback

Found a bug or missing a filter? Open an issue on the [Issues tab](https://apify.com/mrbridge/remote-jobs-mcp/issues) and we will answer there.

More MCP servers, scrapers and data studies from the same team: [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.3.3: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.3.2: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.3.1: pricing events tool-read and tool-action
- 0.3.0: Remotive is a third source next to Jobicy and Arbeitnow (its active remote jobs, shown 24 hours after publication and read once a day). Searches, snapshots, salary statistics and the ChatGPT pair include Remotive jobs, `source` accepts "remotive", and `jobs_get_job`, `jobs_check_status` and `fetch` accept `remotive:<id>` ids and Remotive job links. Also new: the ChatGPT `search` titles name the job board, `jobs_salary_insights` gains `attributions` and a `source` on each top-paying job, an empty answer names the job boards that could not be read, and a search with more than 1,000 matches says how to reach the rest. Contact details are now removed before an excerpt is cut, so no part of a phone number is left at the cut, and cached Jobicy and Arbeitnow answers are read again once after the update. Existing parameters and fields are unchanged.
- 0.2.1: Arbeitnow jobs whose page is on one of its country sites (arbeitnow.ch, arbeitnow.co.uk, arbeitnow.fr) are no longer left out, and job excerpts that Arbeitnow sends as escaped HTML read as plain text. The `sources` note says how many of the newest Arbeitnow listings are remote, usually about a dozen. Arbeitnow answers are read again once after the update.
- 0.2.0: Arbeitnow is a second source next to Jobicy (remote jobs, with Arbeitnow's permission). Searches, snapshots and the ChatGPT pair merge both boards, `jobs_search` and `jobs_market_snapshot` take an optional `source`, answers gain `sources` and `attributions`, and `jobs_get_job`, `jobs_check_status` and `fetch` accept `arbeitnow:<slug>` ids. Existing parameters and fields are unchanged. Cached answers are read again from the job boards once after the update.
  This release also lists the fixes that went live on 2026-10-05 under 0.1.0: full location names such as "United Kingdom" and common category words such as "qa" or "web design" are accepted, `jobs_list_filters` finds a value through its full name, and `level: "lead"` also keeps senior and director jobs whose title names a lead role. Change of meaning: the category "ux" now leads to "Web, UI & UX Design" (`web-app-design`) instead of "Creative & Design" (`design-multimedia`).
- 0.1.0: initial build (private, unpublished)

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--remote-jobs-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mcpEndpoint": "https://mrbridge--remote-jobs-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/remote-jobs-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "mcpEndpoint": "https://mrbridge--remote-jobs-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/remote-jobs-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mcpEndpoint": "https://mrbridge--remote-jobs-mcp.apify.actor/mcp"
}' |
apify call mrbridge/remote-jobs-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/remote-jobs-mcp"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XpO9GXu0mteRRv4dE/builds/jGxVfEd5gD9x0hisS/openapi.json