# Remote Jobs Scraper & Aggregator: Remote OK, WWR, Himalayas (`rel8ble/remote-jobs-aggregator`) Actor

Remote jobs scraper and aggregator API: Remote OK, We Work Remotely, Remotive, Himalayas, Jobicy, Working Nomads and Arbeitnow in one list. Filter by keyword, location, salary, days. One result = one job: title, company, salary, who can apply, type, date, URLs. No login. $0.25 per 1,000.

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

## Pricing

$0.25 / 1,000 results

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 Scraper & Aggregator: Remote OK, WWR, Himalayas

This **remote jobs scraper** and remote job aggregator API collects, in one run, live remote jobs from **Remote OK, We Work Remotely, Remotive, Himalayas, Jobicy, Working Nomads and Arbeitnow**, cleans them into one format and merges the same job posted on several boards into a single row. It works as a Remote OK scraper, We Work Remotely scraper, Remotive scraper, Himalayas scraper and Jobicy scraper at once.

- **What goes in:** optional keywords, exclude words, categories, who can apply (`Worldwide`, `USA`, `Europe`, `UK`, `Germany`, `LATAM`, `APAC` ...), minimum salary, employment type, "posted in the last N days" and a maximum number of jobs. An empty input returns the newest remote jobs from all seven boards.
- **What comes out:** one row per job: title, company, board name and original job URL, apply link, who can apply (countries / regions / worldwide), employment type, seniority, category, tags, salary parsed into min / max / currency / period (plus an approximate yearly USD figure), posted and expiry dates, the other boards that list the same job, and the full description as plain text.
- **Typical cost:** $0.25 per 1,000 jobs, no start fee. 100 jobs = $0.025; every job a filtered search finds is usually a few hundred = about $0.05-0.10.
- **When to use it:** remote job boards and newsletters, "remote jobs in Europe paying $80k+" alerts, job-search agents, salary research on remote roles, and hiring-signal lead lists (which companies hire remotely right now).

It reads the public JSON and RSS feeds these boards publish for re-use, over plain HTTP: no browser, no login, no API keys. Each board asks to be credited with a link back, so every row keeps `sourceName` and the original `sourceUrl`.

### Sample output

Real rows from a local run of the prefilled input on 2026-10-16 (all seven boards, 20 results, 15.3 s), a few of the fields:

| Job | Company | Board | Who can apply | Type | Salary | Posted |
|---|---|---|---|---|---|---|
| Tech Lead Full-Stack Rails Engineer | Mitre Media | Remotive | USA, Canada, USA timezones | Full-time | USD 170,000-200,000 / year | 2026-10-14 |
| Remote Office Assistant | Coalition Technologies | Remotive | Worldwide | Full-time | USD 35,300-52,000 / year | 2026-10-11 |
| Inside Sales Contractor | Credit Wellness, LLC | Remotive | Worldwide | Full-time | USD 25,000-35,000 / year | 2026-10-08 |
| Account Manager Mid Market | Allego | Remote OK | Waltham | - | - | 2026-10-15 |
| Head of Technology | Sanctuary Computer | We Work Remotely | Anywhere in the World · New York | Full-time | - | 2026-10-16 |

Every row also has the original job URL, apply link, eligibility list, tags, approximate yearly USD salary and the description. Remote OK leaves eligibility empty on many jobs, and it wrote only a city on the fourth row.

### Use cases

- **Job boards and newsletters**: fill a remote job board or a weekly newsletter from seven sources, with duplicates merged and a credit link to each board.
- **Job alerts**: "remote React jobs in Europe paying $80k+", scheduled daily with `postedWithinDays: 1`.
- **Job-search agents**: give an AI agent a live feed it can filter by skill, location and salary (see MCP below).
- **Salary research**: compare published remote pay by role and region, parsed into min, max, currency and period.
- **Hiring-signal lead lists**: see which companies hire remotely right now and for which roles.

### Pricing

Pay per result: **$0.25 per 1,000 jobs** (one result = one job saved to the dataset). **No start fee**, no extra charge for descriptions, deduplication or any filter.

- 100 jobs = $0.025
- A daily "new remote jobs today" run across all seven boards (about 4,000 jobs) = about $1.00
- 10,000 jobs = $2.50

Duplicates merged away, jobs your filters drop and failed requests are never charged. If you set a maximum cost per run, the actor stops cleanly at it. Apify platform usage is included in that price, and Apify's free plan ($5 of monthly credit) covers about 20,000 jobs.

Other remote-job aggregators and scrapers on the Store, read 2 Nov 2026 (30-day users in brackets, per 1,000 jobs): memo23 (194) $1.99 + $1.00 extras + $0.0001 start, hirebase (176) $5.00 + $0.001 start, benthepythondev (68) $15.00 + $10.00 salary extra + start, charliemorrisondev (50) $2.00 + start, hyperbach (6) $1.00, several at $0.50, tidyharvest with 3 boards (1) $0.30. Two charge less than this actor: nomad-agent with 4 boards (4) $0.10 + $0.00005 start and forgedata (2) $0.01 + $0.00005 start.

### FAQ

**Do I need API keys for Remote OK, Remotive or Himalayas?**
No. All seven boards publish these feeds publicly without a key.

**How do I show these jobs on my own site?**
Each board asks for credit and a link back. Show `sourceName` and link the job to `sourceUrl` (or `applyUrl`). Remotive also asks not to resubmit its jobs to other aggregators such as Google Jobs or LinkedIn, and to read its feed only a few times a day.

**How do I get only new jobs every day?**
Schedule the actor daily with `postedWithinDays: 1` and keep the `id`s you have already seen.

**Why are there fewer jobs than the boards list?**
Most of Arbeitnow is on-site (only remote jobs are kept), duplicates across boards are merged, and Remote OK / Remotive / Working Nomads publish only their newest jobs. `RUN_SUMMARY` shows the numbers per board.

**Can I get one row per listing instead of merged jobs?**
Set `dedupe: false`.

**Something is wrong or a field is missing.**
Open an issue on the Issues tab of the actor page with the run ID.

### How to use

1. Optional: type **Keywords** (`python`, `data engineer`, `customer support`) and **Exclude keywords** (`senior`, `crypto`). Keywords match whole words in the title, company, category and tags (turn on *Also match keywords in the description* for a wider net).
2. Optional: pick **Who can apply from**: `Worldwide` for jobs open to anyone, or a country / region such as `USA`, `Europe`, `UK`, `Canada`, `Germany`, `LATAM`, `APAC`, `EMEA`. Jobs open worldwide are included too unless you switch that off.
3. Optional: set **Minimum salary (USD per year)**, **Employment types**, **Categories / tags** and **Posted within (days)**.
4. Set **Max jobs** (0 = no limit) and click **Start**. Download the dataset as JSON, CSV, Excel or HTML, or read it through the Apify API, Make, Zapier, n8n or an MCP client.

Leave **Sources** on all seven, or untick boards you do not want. When the same job is on several boards, the copy from the board listed first is kept and the others are listed in `alsoListedOn`.

### The seven boards

| Board | What the run reads | Live remote jobs per run (2026-10-16) |
|---|---|---|
| Remote OK | `remoteok.com/api` | ~100 newest |
| We Work Remotely | main RSS feed + 11 category feeds | ~410 |
| Remotive | free public feed (Remotive publishes a small, 24-hour-delayed set) | ~15 |
| Himalayas | the whole job feed (newest first) or its search, per keyword | ~125,000 (~103,000 after merging the same job posted for several countries) |
| Jobicy | the whole feed (about the last 7 days) | ~730 |
| Working Nomads | public feed | ~50 newest |
| Arbeitnow | the whole feed; only jobs marked remote are kept | ~1,300 of ~12,000 |

### Input example

| Field | Default | Description |
|---|---|---|
| `sources` | all seven | `remoteok`, `weworkremotely`, `remotive`, `himalayas`, `jobicy`, `workingnomads`, `arbeitnow` |
| `keywords` | - | Words or phrases, any of them must match (whole words) |
| `excludeKeywords` | - | Drop jobs containing any of these |
| `keywordsInDescription` | false | Also match keywords in the description |
| `tags` | - | Category / tag words, e.g. `Design`, `DevOps`, `Marketing` |
| `locations` | - | `Worldwide`, a country (`USA`, `UK`, `Germany`) or a region (`Europe`, `LATAM`, `APAC`, `EMEA`) |
| `includeWorldwide` | true | With `locations`, also keep jobs open worldwide |
| `includeUnknownLocation` | false | With `locations`, also keep jobs that do not say where |
| `employmentTypes` | all | `Full-time`, `Part-time`, `Contract`, `Freelance`, `Internship`, `Temporary` |
| `minSalary` | - | USD per year (other currencies and hourly / monthly pay converted approximately) |
| `includeNoSalary` | false | With `minSalary`, keep jobs that publish no salary |
| `postedWithinDays` | any | 1, 3, 7 ... |
| `dedupe` | true | Merge the same job across boards |
| `maxItems` | 100 | Most jobs in total; 0 = no limit |
| `includeDescription` | true | Full description as plain text |
| `includeDescriptionHtml` | false | Also the original HTML |

Python and data-engineering jobs open to people in Europe, posted in the last week, no internships, Europe-named jobs only (this exact input returned 114 jobs in a test run):

```json
{
    "keywords": ["python", "data engineer"],
    "excludeKeywords": ["intern"],
    "locations": ["Europe"],
    "includeWorldwide": false,
    "postedWithinDays": 7,
    "maxItems": 200
}
```

Full-time US jobs paying at least $100,000 a year, without descriptions (100 jobs in 31 seconds in a test run):

```json
{
    "sources": ["remoteok", "weworkremotely", "remotive", "himalayas", "jobicy", "workingnomads"],
    "locations": ["USA"],
    "minSalary": 100000,
    "employmentTypes": ["Full-time"],
    "includeDescription": false,
    "maxItems": 100
}
```

Everything new on all seven boards today, one row per job:

```json
{
    "postedWithinDays": 1,
    "maxItems": 0
}
```

### Output example

From real runs on 2026-10-16 (descriptions shortened). A job found on two boards, merged; the expiry date was filled in from the We Work Remotely listing:

```json
{
    "id": "jobicy:155411",
    "source": "jobicy",
    "sourceName": "Jobicy",
    "sourceId": "155411",
    "sourceUrl": "https://jobicy.com/jobs/155411-care-coach",
    "title": "Care Coach",
    "company": "Maven Clinic",
    "companyUrl": null,
    "companyLogo": "https://jobicy.com/data/server-nyc0409/galaxy/mercury/2026/07/c4b2d5ecf34b-221.webp",
    "location": "USA",
    "locationRestrictions": ["USA"],
    "isWorldwide": false,
    "timezoneRestrictions": null,
    "employmentType": "Contract",
    "seniority": "Senior",
    "category": "Healthcare & Medical",
    "tags": ["Healthcare & Medical"],
    "salaryText": null,
    "salaryMin": 62000,
    "salaryMax": 78000,
    "salaryCurrency": "USD",
    "salaryPeriod": "year",
    "salaryYearlyUsdMin": 62000,
    "salaryYearlyUsdMax": 78000,
    "postedAt": "2026-10-16T13:27:06.000Z",
    "expiresAt": "2026-11-15T07:30:50.000Z",
    "applyUrl": "https://jobicy.com/jobs/155411-care-coach",
    "alsoListedOn": [
        {
            "source": "weworkremotely",
            "sourceName": "We Work Remotely",
            "id": "weworkremotely:maven-clinic-care-coach",
            "url": "https://weworkremotely.com/remote-jobs/maven-clinic-care-coach",
            "postedAt": "2026-10-16T07:30:50.000Z"
        }
    ],
    "firstSeenAt": "2026-10-16T07:30:50.000Z",
    "scrapedAt": "2026-10-16T18:58:18.378Z",
    "description": "Maven Clinic is the world's largest virtual clinic for women and families on a mission to make healthcare work for all of us. Through Maven Enterprise, the company partners with more than 2,300 employers and health plans ..."
}
```

A Himalayas job with a time-zone restriction (`includeDescription: false`):

```json
{
    "id": "himalayas:companies/ss8-networks/jobs/business-development-associate-state-local-government",
    "source": "himalayas",
    "sourceName": "Himalayas",
    "sourceUrl": "https://himalayas.app/companies/ss8-networks/jobs/business-development-associate-state-local-government",
    "title": "Business Development Associate – State & Local Government",
    "company": "SS8 Networks",
    "companyUrl": "https://himalayas.app/companies/ss8-networks",
    "location": "United States",
    "locationRestrictions": ["United States"],
    "isWorldwide": false,
    "timezoneRestrictions": [-10, -9, -8, -7, -6, -5, 14],
    "employmentType": "Full-time",
    "seniority": "Entry-level",
    "category": "Sales",
    "tags": ["Sales", "Business Development Associate", "Sales Associate", "Government Sales", "Public Sector Sales"],
    "salaryMin": 90000,
    "salaryMax": 110000,
    "salaryCurrency": "USD",
    "salaryPeriod": "year",
    "salaryYearlyUsdMin": 90000,
    "salaryYearlyUsdMax": 110000,
    "postedAt": "2026-10-16T17:40:48.000Z",
    "expiresAt": "2026-12-15T17:40:47.000Z",
    "applyUrl": "https://himalayas.app/companies/ss8-networks/jobs/business-development-associate-state-local-government",
    "alsoListedOn": []
}
```

Fill rates from a test run over every board with no limit and no filters (105,141 jobs, 102,800 of them from Himalayas): id, board, URLs, title, company, location line, posted date, apply link and description 100%; employment type 99%; seniority 98%; company page 98%; expiry date 98%; eligibility list 97%; company logo 82%; category 72%; salary figures 34%. Per board, salary: Jobicy 48%, Remotive 55%, Himalayas 34%, Remote OK 20%, We Work Remotely / Working Nomads / Arbeitnow none in their feeds. Remote OK leaves the location empty on 43% of its jobs.

A field a board does not publish is `null` (or an empty list), never guessed. The run's key-value store also holds `RUN_SUMMARY`: per board, how many jobs were fetched, matched the filters, were merged as duplicates and were saved, how many pages were read, why it stopped, and anything that failed.

### Integrations

- **Apify API**: start runs and read results over REST, or with the [Python](https://docs.apify.com/api/client/python) and [JavaScript](https://docs.apify.com/api/client/js) clients.
- **MCP for AI agents**: through the Apify MCP server (https://mcp.apify.com), Claude, ChatGPT, Cursor and other agents can call this actor directly ("find remote React jobs open to Europe posted this week paying over $90k") and read the rows. Every input field is described for agents.
- **Make, Zapier, n8n**: send new jobs to Slack, Discord, Google Sheets, Airtable, Notion or your CRM.
- **Schedules + webhooks**: run every morning with `postedWithinDays: 1` and keep only `id`s you have not seen.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("rel8ble/remote-jobs-aggregator").call(run_input={
    "keywords": ["python"],
    "locations": ["Europe"],
    "postedWithinDays": 3,
    "maxItems": 100,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], "|", job["company"], "|", job["sourceName"], "|", job["location"], "|", job["sourceUrl"])
```

### Limits (read before large runs)

- **Speed is set by the boards' rate limits.** Himalayas allows about 100 requests a minute (20 jobs each), so about 1,700 Himalayas jobs a minute; a no-limit, no-filter run reads its whole ~125,000-job feed and took 69 minutes in testing. One day of new jobs (`postedWithinDays: 1`, about 4,000 jobs) took about 6 minutes. Arbeitnow allows about 30 pages a minute and is ~90% on-site jobs, so a run that needs its whole feed takes about 3 minutes. Use `postedWithinDays` (feeds are read newest first and stop at the cut-off) or untick boards for faster runs.
- **Keyword searches on Himalayas** use its search, which returns at most the 5,000 newest matches per keyword; the run summary says when that happened. Its search is fuzzy, so the actor re-checks every keyword itself.
- **Remotive's free feed** is a small fixed set (about 15 jobs, published 24 hours late). Remote OK and Working Nomads publish only their newest ~100 and ~50 jobs.
- **Who can apply** is read from each board's own eligibility line, which boards write differently ("USA timezones", "EMEA or APAC time zones only", a list of 70 countries). Remote OK leaves it empty on many jobs; those are only kept with `includeUnknownLocation`. Arbeitnow jobs with only a city are taken as Germany-based.
- **Salary** is published by Himalayas, Jobicy, Remote OK (USD) and Remotive (text); We Work Remotely, Working Nomads and Arbeitnow feeds carry none. `salaryYearlyUsd*` uses fixed approximate exchange rates and 2,080 hours a year.
- **Duplicates** are matched on company + title after cleaning ("Sr." = "Senior", "(m/w/d)" and "Remote" removed). The same title at the same company in two locations is also merged. With no limit, Himalayas copies of jobs already saved from another board are skipped rather than listed in `alsoListedOn`.
- **No personal data.** Recruiter names, e-mail addresses and phone numbers are not collected as fields; e-mail addresses and phone numbers inside descriptions are replaced with `[email removed]` / `[phone removed]`.

Need a custom scraper or a ready dataset? Hire me on Fiverr: https://www.fiverr.com/rel8ble

# Actor input Schema

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

Optional. Which job boards to read: any of "remoteok", "weworkremotely", "remotive", "himalayas", "jobicy", "workingnomads", "arbeitnow". Default = all seven. When the same job is on several boards, the copy from the board listed first is kept and the others go into alsoListedOn.

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

Optional. Keep jobs whose title, company, category or tags contain any of these words or phrases, one per line: "python", "data engineer", "customer support", "react". Whole words only ("java" does not match "JavaScript"). Empty = every remote job.

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

Optional. Drop jobs whose title, company, category or tags contain any of these words, one per line: "senior", "sales", "crypto". Whole words only.

## `keywordsInDescription` (type: `boolean`):

Optional. Also look for the keywords in the full job description, not only in title / company / category / tags. Finds more jobs but less precise. Default false.

## `tags` (type: `array`):

Optional. Keep jobs whose category or tags contain any of these, one per line: "Design", "DevOps", "Marketing", "Software Development", "Customer Support". Each board names its categories differently, so short words work best. Empty = all categories.

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

Optional. Countries or regions you want to be eligible from, one per line: "Worldwide", "USA", "Europe", "UK", "Germany", "Canada", "LATAM", "APAC", "EMEA". A job matches when its "who can apply" line names that place, a region that contains it (Germany matches a job open to "Europe" or "EMEA") or a place inside it (Europe matches a job open to "Germany"). "Worldwide" = only jobs open to anyone anywhere. Empty = no location filter.

## `includeWorldwide` (type: `boolean`):

Optional. With a location filter, also keep jobs that are open worldwide (anyone can apply). Default true. Set false to get only jobs that explicitly name your country or region.

## `includeUnknownLocation` (type: `boolean`):

Optional. With a location filter, also keep jobs that give no location or eligibility at all (common on Remote OK). Default false.

## `employmentTypes` (type: `array`):

Optional. Keep only these types: any of "Full-time", "Part-time", "Contract", "Freelance", "Internship", "Temporary". Jobs that do not state a type are dropped when this is set. Empty = all.

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

Optional. Keep jobs whose top of range is at least this much per year in US dollars, e.g. 80000. Hourly, daily and monthly pay and other currencies are converted with fixed approximate rates (2,080 hours a year). Jobs that show no salary are dropped unless "Keep jobs without a salary" is on. 0 or empty = no minimum.

## `includeNoSalary` (type: `boolean`):

Optional. With a minimum salary set, also keep jobs that do not publish any salary. Default false.

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

Optional. Only jobs posted in the last N days, e.g. 1 for today and yesterday, 7 for the last week. Feeds are read newest first and stop at the cut-off, so this also makes runs faster. 0 or empty = any date.

## `dedupe` (type: `boolean`):

Optional. Default true: the same job (same company and same title after cleaning, e.g. "Sr." = "Senior", "(m/w/d)" removed) listed on several boards becomes one row; the other listings are in alsoListedOn with their own URLs. Set false to get one row per listing.

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

Optional. Most jobs to save in total. When this cuts the list, every board gets a fair share (round-robin, newest first). 0 = no limit (all matching jobs from all boards, about 100,000+ without filters, most of them from Himalayas). Default 100.

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

Optional. Default true: each job gets its full description as plain text (HTML removed; e-mail addresses and phone numbers replaced). Set false for smaller rows.

## `includeDescriptionHtml` (type: `boolean`):

Optional. Also save the description as the board published it (HTML), in descriptionHtml. Default false.

## `maxConcurrency` (type: `integer`):

Optional. Parallel requests. Default 10 is fine; Arbeitnow is always paced to its own limit.

## `maxRequestRetries` (type: `integer`):

Optional. Retries for a failed or rate-limited request (with a new session each time). Default 6.

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

Optional. Not needed: all seven boards publish these feeds for re-use and answer direct requests. Default no proxy.

## Actor input object example

```json
{
  "sources": [
    "remoteok",
    "weworkremotely",
    "remotive",
    "himalayas",
    "jobicy",
    "workingnomads",
    "arbeitnow"
  ],
  "keywordsInDescription": false,
  "locations": [],
  "includeWorldwide": true,
  "includeUnknownLocation": false,
  "includeNoSalary": false,
  "dedupe": true,
  "maxItems": 20,
  "includeDescription": true,
  "includeDescriptionHtml": false,
  "maxConcurrency": 10,
  "maxRequestRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All remote jobs found: title, company, board and original URL, who can apply (countries / regions / worldwide), employment type, category, tags, salary (parsed), posted date, apply link, other boards listing the same job and (when on) the description.

## `summary` (type: `string`):

Per-board counts (fetched, matching the filters, merged as duplicates, saved), pages read, why each board stopped, and anything that failed.

# 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 = {
    "sources": [
        "remoteok",
        "weworkremotely",
        "remotive",
        "himalayas",
        "jobicy",
        "workingnomads",
        "arbeitnow"
    ],
    "locations": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rel8ble/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 = {
    "sources": [
        "remoteok",
        "weworkremotely",
        "remotive",
        "himalayas",
        "jobicy",
        "workingnomads",
        "arbeitnow",
    ],
    "locations": [],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rel8ble/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 '{
  "sources": [
    "remoteok",
    "weworkremotely",
    "remotive",
    "himalayas",
    "jobicy",
    "workingnomads",
    "arbeitnow"
  ],
  "locations": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rel8ble/remote-jobs-aggregator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rel8ble/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/L0DjBrXdHOUgIRPOO/builds/VmQ5KvujNAvGiEFGd/openapi.json
