# Remote Jobs API (`relomote/remote-jobs-api`) Actor

520,000+ live remote and hybrid jobs from 67,000+ companies, straight from their career pages on 63 applicant tracking systems. Where each job hires from, salary, application questions and the employer's apply link. The official Relomote feed.

- **URL**: https://apify.com/relomote/remote-jobs-api.md
- **Developed by:** [Relomote](https://apify.com/relomote) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 API

**520,000+ live remote and hybrid jobs from 67,000+ companies, straight from their career pages on 63 applicant tracking systems.** Every job says where it can hire from. This is the official jobs feed of [Relomote](https://relomote.com), a remote job board.

| As of October 11, 2026 | |
|---|---|
| Live jobs | 520,791 |
| Companies with live jobs | 67,429 |
| Company career pages Relomote checks | 254,284 |
| Applicant tracking systems | 63 |

| Jobs added | |
|---|---|
| July 2026 | 164,651 |
| August 2026 | 142,476 |
| September 2026 | 278,309 |

A month's jobs are those Relomote found that month that made it onto the board, including those that have closed since.

- **Where the job hires from,** in `location`: one country ("Germany") or several ("United States, Canada"), a region ("Europe"), "Worldwide" when the posting says it hires from anywhere, or "Probably Worldwide" when it lists no location limit but doesn't say so outright.
- **Straight from employers:** every apply link goes to the employer's own application page, on one of 63 applicant tracking systems or the employer's own careers site.
- **The application form's questions** for about half the jobs: every field's label, type, options and whether it is required.
- **Salary** when the posting gives one, employment type, category, and the full description as text and, when the source had markup, as HTML.
- **No scraping on your side:** the Actor reads Relomote's feed directly, so runs are fast.

### What you can filter on

| Input | What it does |
|---|---|
| Job titles or keywords | Up to 5 searches, one per line. A job matches if its title or company name has every word of any one line; a few common translations count too, so "nurse" also finds "Enfermeira". |
| Hiring from | Countries, regions or "worldwide". A country also returns the jobs open to its whole region and the worldwide ones, because those hire from there too. |
| Categories | Engineering, Customer Support, Data & Analytics, Healthcare & Nursing and 18 more. |
| Work arrangement | Remote and hybrid, remote only, or hybrid only. |
| Minimum salary | The top of the posted range, in US dollars a year. |
| Added in the last | Only jobs that reached Relomote in this many hours. |
| Maximum jobs | Newest first, 10 to 5,000 a run. |
| Return | Jobs, or the ids of the jobs that closed, to remove them from your copy. |
| Closed in the last | With Return set to closed job ids: how many hours back, up to a week. |

### Output

One item per job (the questions and description are shortened here):

```json
{
  "id": 190958308,
  "board": "remote",
  "title": "Developer Relations Manager",
  "company": "Boson AI",
  "ats": "lever",
  "apply_url": "https://jobs.lever.co/bosonai/2dbede2c-e0ad-4691-84ba-99e6755aebe8",
  "location": "United States",
  "work_arrangement": "hybrid",
  "category": "Engineering & Development",
  "salary": { "min": 180000, "max": 280000, "currency": "USD", "period": "year" },
  "employment_type": ["FULL_TIME"],
  "date_posted": "2026-10-06T02:15:42.885Z",
  "first_seen_at": "2026-10-11T05:00:54.227Z",
  "added_at": "2026-10-11T06:22:01.882Z",
  "last_checked_at": "2026-10-11T12:47:31.456Z",
  "application_deadline": null,
  "application_questions": [
    { "type": "file", "label": "Resume/CV", "required": true },
    { "type": "text", "label": "Full name", "required": true },
    { "type": "text", "label": "Email", "required": true },
    { "type": "text", "label": "Where can we find samples of your code? URL", "required": false }
  ],
  "description_text": "About The Role\nBoson AI builds real-time speech and multimodal AI…",
  "description_html": "<div><strong>About The Role</strong></div>…"
}
```

| Field | Meaning |
|---|---|
| `id` | Relomote's id for the job. It never changes, so use it to skip jobs you already have. |
| `location` | Where a candidate can be. One country or several, comma-separated; a region (Africa, Asia, Europe, Latin America, Middle East, North America or Oceania); "Worldwide"; or "Probably Worldwide" (the posting lists no location limit but doesn't say it hires from anywhere). |
| `work_arrangement` | "remote" or "hybrid". |
| `salary` | `{ min, max, currency, period }`, with `period` one of hour, day, week, month or year, or null when the posting doesn't say (41% of salaries; most of those are yearly, and the salary filter reads them as yearly). Null when the posting has no salary. |
| `date_posted` | The date the employer's posting gives. Null when it gives none. About 4 in 10 postings give a day without a time, which shows as midnight UTC. |
| `first_seen_at` | When Relomote first found the job on the employer's site. |
| `added_at` | When the job reached Relomote's board. A job can be found days before it is classified and listed, so sync on this, not on `date_posted`. |
| `last_checked_at` | The last time the job was seen live on the employer's site. Most career pages are re-checked several times a day: on October 11, 2026, 90% of live jobs had been seen in the previous 9 hours. Workable pages are re-checked about every 4 days. |
| `application_questions` | The application form's fields: `type` as the applicant tracking system names it, `label`, `required` and `options`. Null when the form wasn't read. |

### Good to know

Not every posting has every field. Measured on the live board on October 11, 2026:

| Field | Filled for |
|---|---|
| `application_questions` | About 55% of jobs. Forms on Greenhouse, Ashby, Lever, BambooHR and Recruitee are almost always read; forms on Workday, SmartRecruiters, iCIMS and Oracle are not read at all. |
| `date_posted` | About 88% |
| `employment_type` | About 60% |
| `salary` | About 35% |
| `description_html` | About two thirds. The rest have plain text only, in `description_text`. |
| `application_deadline` | About 3% |

Where a job hires from, its work arrangement and its category are read from the posting by software. They are right most of the time, not every time, so check the posting before relying on one.

### How a run works

- A run returns jobs that are live on Relomote right now, newest first by when Relomote found them, up to **Maximum jobs** (10 to 5,000).
- **Added in the last** keeps only the jobs that reached the board in that many hours, for any number of hours.
- The feed is the live board: a job is in it within about 10 minutes of being listed, and out of it as soon as Relomote sees it has closed.

### Keeping a copy up to date

1. **Start:** run once without **Added in the last** for the newest 5,000 jobs. For more, run once per category or location.
2. **Stay current:** schedule the Actor, set **Added in the last** an hour longer than the time between runs, and skip ids you already have. The whole board gains about 10,000 jobs a day, more than one run's 5,000, so for all of it run every 6 hours with 7 hours. A narrower copy, say one category, can run daily with 25 hours.
3. **Remove closed jobs:** jobs close about as fast as they arrive, between about 2,000 and 17,000 a day in the week to October 11, 2026. Once a day, run the Actor with **Return** set to "Closed job ids" and **Closed in the last** at 25 hours, then delete those ids from your copy. The list covers the whole board, whatever the filters.

The list is saved as the `OUTPUT` record of the run's key-value store, not in the dataset, most recently closed first:

```json
{ "board": "remote", "closed_since": "2026-10-10T21:00:00.000Z", "total": 3, "ids": [190958308, 190958301, 190958297] }
```

A job is on it within about 10 minutes of Relomote seeing it closed. For a scheduled task, the latest list is at `https://api.apify.com/v2/actor-tasks/<task id>/runs/last/key-value-store/records/OUTPUT?status=SUCCEEDED&token=<your token>`.

### Price

$6 per 1,000 jobs on Apify's Free and Starter plans, $3 on Scale and Business. Free plans get 100 jobs a run.

A closed job ids list is $0.75 a run on every plan, however many ids it holds.

### Using the data

The jobs are yours to use: on your own site or app, in your product, or passed on to others. No credit to Relomote is needed. Job descriptions are the employers' own text.

Questions or a wrong label? Open an issue on this Actor.

# Actor input Schema

## `searches` (type: `array`):

Up to 5 searches, one per line, e.g. "customer support" or "react developer". A job matches if its title or company name has every word of any one line. Empty lists the newest jobs.

## `locations` (type: `array`):

Where the candidate is. A country ("Germany" or "DE"), a region (Africa, Asia, Europe, Latin America, Middle East, North America, Oceania) or "worldwide" for jobs open from anywhere. A country also returns the jobs open to its whole region and the worldwide ones, since those hire from there too.

## `categories` (type: `array`):

Leave empty for every category.

## `workArrangement` (type: `string`):

Remote and hybrid jobs, remote only, or hybrid only.

## `minSalary` (type: `string`):

The top of the posted salary range, converted to US dollars a year. Jobs without a posted salary are left out when this is set.

## `addedWithinHours` (type: `integer`):

Only jobs that reached Relomote in this many hours. To keep a copy up to date, schedule the Actor and set this an hour longer than the time between runs, then skip ids you already have.

## `maxItems` (type: `integer`):

Newest first. 10 to 5,000 a run; free Apify plans get 100.

## `output` (type: `string`):

Jobs, or one list of the ids of the jobs on the whole board that closed in the hours set below, saved as the OUTPUT record in the run's key-value store and charged once per run. Delete those jobs from your copy. The filters above don't apply to it.

## `closedWithinHours` (type: `integer`):

With Return set to closed job ids: the jobs that closed in this many hours, up to a week. Run it daily with 25; the extra hour covers the gap between runs.

## Actor input object example

```json
{
  "workArrangement": "any",
  "minSalary": "any",
  "maxItems": 100,
  "output": "jobs",
  "closedWithinHours": 25
}
```

# Actor output Schema

## `jobs` (type: `string`):

One item per job, when Return is Jobs.

## `closedIds` (type: `string`):

The ids of the jobs that closed in the chosen hours, when Return is Closed job ids.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("relomote/remote-jobs-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("relomote/remote-jobs-api").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 '{}' |
apify call relomote/remote-jobs-api --silent --output-dataset

```

## MCP server setup

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

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/6ldD2s5UzNMynP2I8/builds/yqI9xd363UxGcOFtI/openapi.json