# Remote Jobs Aggregator — RemoteOK, WWR, Remotive & More (`yugenox/remote-jobs-aggregator`) Actor

Remote jobs from Remote OK, We Work Remotely, Remotive, Jobicy, Arbeitnow and Working Nomads in one deduplicated dataset: title, company, category, tags, job type, location, salary, posted date, full description and apply link. Keyword, region, salary and date filters; only-new mode.

- **URL**: https://apify.com/yugenox/remote-jobs-aggregator.md
- **Developed by:** [Yugenox Corp](https://apify.com/yugenox) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 remote jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Aggregator: Remote OK, We Work Remotely, Remotive, Jobicy, Arbeitnow & Working Nomads

Get **remote jobs from six of the biggest remote job boards in one clean dataset**: Remote OK, We Work Remotely, Remotive, Jobicy, Arbeitnow and Working Nomads. Every job comes in the same format, with title, company, category, tags, job type, seniority, location and whether it is open worldwide, salary range with currency and period, posted date, the full description (text and HTML) and the link to the original listing. Jobs that are cross-posted to several boards are **merged into one row**, and the other boards are listed in `alsoOn`. Filter by keyword, category, job type, region, minimum salary, posting date and company, and run it on a schedule with **Only new jobs** so you only get what's new since the last run. No login, no cookies, no account.

### What you get

| | |
|---|---|
| **Job** | Title, the board's category plus one shared category list (software development, DevOps & IT, data, design, product, customer support, sales & marketing, management & finance, writing, HR), tags / skills, job type (full-time, part-time, contract, freelance, internship), seniority level |
| **Company** | Name, logo, website and headquarters when the board gives them |
| **Where** | The location as the board writes it (countries, regions, time zones) and `isWorldwide`: open worldwide, restricted, or not stated |
| **Pay** | Salary from / to, currency (USD, EUR, GBP, SEK …) and period (year, month, hour …) when the job publishes one |
| **When** | Posted date and, for We Work Remotely, the listing's expiry date |
| **The ad** | The complete description as plain text and as HTML |
| **Links** | The job page on the board and the apply link, plus the same job on other boards (`alsoOn`) |
| **Search** | Which of your keywords the job matched |

### Use cases

- **Remote-job newsletters and communities**: a fresh, deduplicated list every morning, filtered to your niche (e.g. design jobs open to Europe, paying $80k+).
- **Job boards and aggregators**: back-fill your board with remote listings from six sources in one format, each row linking to the original job.
- **Recruiters and sourcers**: see which companies are hiring remotely for a skill or role right now, with salary ranges.
- **Job seekers**: one search over six boards instead of six tabs, with alerts via a scheduled run.
- **Market research**: track remote hiring by category, region, salary and seniority over time.

### How to use it

1. Enter **Keywords** (job titles or skills such as `engineer`, `product designer`, `customer support`, `python`), or leave them empty to get every remote job.
2. Optionally pick **Job boards**, **Categories**, **Job types**, **Regions / countries**, a **Minimum salary**, **Posted within (days)** or **Companies**.
3. Set **Max jobs** (0 = everything the boards publish right now, usually 1,000–1,700 remote jobs) and run.

Results are sorted **newest first** across all boards.

#### Input examples

The 10 newest engineering jobs from all six boards:

```json
{
  "keywords": ["engineer"],
  "maxItems": 10
}
```

Design and product jobs open to people in Europe, posted in the last 3 days:

```json
{
  "categories": ["design", "product"],
  "regions": ["Europe"],
  "postedWithinDays": 3,
  "maxItems": 200
}
```

A daily newsletter feed: developer jobs paying at least $100,000 a year, only the ones not delivered before (schedule it daily):

```json
{
  "keywords": ["developer", "engineer"],
  "minSalary": 100000,
  "onlyNew": true,
  "maxItems": 0
}
```

Everything from We Work Remotely and Remotive, at most 50 per board:

```json
{
  "sources": ["weworkremotely", "remotive"],
  "maxItems": 0,
  "maxItemsPerSource": 50
}
```

### Output example

A real row (description shortened):

```json
{
  "id": "jobicy:157680",
  "source": "jobicy",
  "sourceName": "Jobicy",
  "sourceJobId": "157680",
  "title": "Staff Software Engineer, Containers",
  "company": "Chainguard",
  "companyLogo": "https://jobicy.com/data/server-nyc0409/galaxy/mercury/2025/06/e4b6aacf-221.jpeg",
  "companyWebsite": null,
  "companyHeadquarters": null,
  "category": "Software Engineering",
  "categories": ["software-development"],
  "tags": [],
  "jobType": "full-time",
  "jobTypeRaw": "Full-Time",
  "level": "Senior",
  "location": "Canada, Germany, UK, USA",
  "isWorldwide": false,
  "salaryMin": 205000,
  "salaryMax": 231000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedAt": "2026-10-28T16:55:29.000Z",
  "expiresAt": null,
  "description": "Chainguard is the trusted source for open source. By delivering hardened, secure, and production-ready builds of all the open source software…",
  "descriptionHtml": "<p><a href=\"https://jobicy.com/company/chainguard\" target=\"_blank\" rel=\"noopener\">Chainguard</a> is the trusted source…",
  "url": "https://jobicy.com/jobs/157680-staff-software-engineer-containers",
  "applyUrl": "https://jobicy.com/jobs/157680-staff-software-engineer-containers",
  "alsoOn": [],
  "matchedKeywords": ["engineer"],
  "scrapedAt": "2026-10-29T05:09:58.117Z"
}
```

A cross-posted job keeps the most complete copy and lists the others:

```json
"alsoOn": [
  { "source": "remotive", "sourceName": "Remotive", "url": "https://remotive.com/remote-jobs/software-development/senior-back-end-developer-2091135", "postedAt": "2026-10-27T12:56:13.000Z" }
]
```

Download the dataset as JSON, CSV, Excel or HTML, or read it through the Apify API. Each run also saves a `RUN_REPORT` record with per-board counts.

### Pricing

Pay per result: **$1.50 per 1,000 jobs** saved, plus **$0.003 per run** (start fee). You only pay for jobs that end up in your dataset: jobs removed by your filters, duplicates merged into another row, and jobs skipped by **Only new jobs** are never charged. Example: 200 jobs cost $0.30 + $0.003.

### Tips

- **Keywords match the job title by default.** Switch **Match keywords in** to "Job title + tags / skills" to also catch jobs that list the skill as a tag, or to "Anywhere" to search the full description.
- End a keyword with `*` to match word beginnings: `develop*` finds developer and development.
- **Regions**: `USA` also matches "United States" and "North America"; `Europe` also matches European country names. Keep **Also keep "work from anywhere" jobs** on to include jobs open worldwide.
- **Minimum salary** only keeps jobs that publish a salary; it compares the top of the range in US dollars per year.
- **Only new jobs** remembers what was delivered per search, so different searches keep separate memories. A scheduled run that finds nothing new is cheap: it reads only the boards' first pages and pays only the start fee.
- Arbeitnow lists many on-site jobs in Germany and Europe; only the ones it marks as remote are included, and their location is the city the company is in.
- Each row keeps the original job URL and the board's name, so you can credit and link back to the source board when you republish jobs.

### FAQ

**Which job boards are included?**
Remote OK, We Work Remotely, Remotive, Jobicy, Arbeitnow (remote jobs only) and Working Nomads. Pick any subset with **Job boards**.

**How many jobs can I get?**
Everything the six boards publish at the moment of the run, usually 1,000–1,700 remote jobs in total. Set **Max jobs** to 0 for all of them.

**How are duplicates detected?**
Jobs with the same company and the same title (ignoring extras like "(Remote)", "| Sweden", "Inc.") are one job. The row with the most information (salary, description, location, logo, tags) is kept and the others are listed in `alsoOn`.

**How fresh is the data?**
Every run reads the boards live. Most of the boards add new jobs every hour.

**What if a board is down?**
The other boards are still read and saved; the run's status message names the board that could not be read. You are never charged for jobs that were not delivered.

**Is it legal to scrape Remote OK, We Work Remotely, Remotive, Jobicy, Arbeitnow and Working Nomads?**
This actor reads only public job listings that the boards publish openly for anyone, without logging in, and it follows each site's robots.txt. Job listings are business information published to be seen widely. When you republish jobs, credit the source board and link back to the original listing (every row includes both). For advice on your specific use, consult a lawyer.

**Does it access any private data?**
No. It reads only public job listings. No login, cookies or accounts are used. Personal e-mail addresses and phone numbers that sometimes appear inside job descriptions (a recruiter's direct contact) are masked as `[email removed]` / `[phone removed]`; company mailboxes such as careers@ or jobs@ are kept.

**Can I run it on a schedule?**
Yes. Create a schedule in Apify Console (e.g. every morning) and turn on **Only new jobs**; connect the dataset to Google Sheets, Slack, Zapier, Make or a webhook to get new jobs delivered automatically.

# Actor input Schema

## `keywords` (type: `array`):

Job titles or skills to look for, e.g. "engineer", "product designer", "customer support", "python". A job is kept when it matches ANY keyword. End a word with \* to match its beginning ("develop\*" = developer, development). Leave empty to get every remote job (optionally narrowed by the filters below).

## `keywordScope` (type: `string`):

Where a keyword has to appear: the job title (and the board's category), the title plus the job's tags / skills, or anywhere including the company name and the full description.

## `excludeKeywords` (type: `array`):

Drop jobs whose title or tags contain any of these words, e.g. "senior", "intern", "sales".

## `sources` (type: `array`):

Which job boards to read. Empty = all six.

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

Keep only jobs in these categories (the boards' own categories mapped to one shared list). Empty = all.

## `jobTypes` (type: `array`):

Keep only these employment types. Jobs whose board does not say the type are left out when this is set. Empty = all.

## `regions` (type: `array`):

Keep jobs open to people in these places, e.g. "USA", "Europe", "UK", "Canada", "LATAM", "APAC", "Germany". Matched against the job's location ("USA" also matches "United States" and "North America").

## `includeAnywhere` (type: `boolean`):

With a region set, also keep jobs open worldwide or that don't name a region.

## `minSalary` (type: `integer`):

Keep only jobs that publish a salary whose top end reaches this amount, converted to US dollars per year (hourly × 2,080, monthly × 12; other currencies at approximate rates). Jobs without a salary are left out when this is set. 0 = no minimum.

## `postedWithinDays` (type: `integer`):

Keep only jobs posted in the last N days. 0 = any date.

## `companies` (type: `array`):

Keep only jobs from these companies (name contains the text, e.g. "GitLab", "Automattic").

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

Maximum number of jobs to save, newest first, after cross-posted duplicates are merged. 0 = everything the boards publish right now (usually 1,000–1,700 remote jobs).

## `maxItemsPerSource` (type: `integer`):

Optional cap per job board, so one busy board can't fill the whole result. 0 = no cap.

## `onlyNew` (type: `boolean`):

Skip jobs that an earlier run with the same search and filters already saved (they are not saved again and not charged). Ideal for a daily or hourly schedule feeding a newsletter or job board.

## `includeDescription` (type: `boolean`):

Save the job description as plain text and as HTML. Turn off for smaller rows.

## `proxyConfiguration` (type: `object`):

Apify Proxy (datacenter) is the default and comes with every Apify plan; all six boards answer it.

## `_noResidential` (type: `boolean`):

Internal (canaries): behave exactly like an account without the RESIDENTIAL proxy group.

## Actor input object example

```json
{
  "keywords": [
    "engineer"
  ],
  "keywordScope": "title",
  "includeAnywhere": true,
  "minSalary": 0,
  "postedWithinDays": 0,
  "maxItems": 10,
  "maxItemsPerSource": 0,
  "onlyNew": false,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "_noResidential": false
}
```

# Actor output Schema

## `results` (type: `string`):

All saved remote jobs, newest first.

## `run` (type: `string`):

Status and statistics for this run.

## `report` (type: `string`):

RUN_REPORT: how the run ended, per-board counts, requests and proxy use.

# 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 = {
    "keywords": [
        "engineer"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yugenox/remote-jobs-aggregator").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 = {
    "keywords": ["engineer"],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("yugenox/remote-jobs-aggregator").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 '{
  "keywords": [
    "engineer"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call yugenox/remote-jobs-aggregator --silent --output-dataset

```

## MCP server setup

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

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/zz5XL80MopG7Q0Pre/builds/JtLucRS5fI5QebCJ5/openapi.json