# Remote Jobs Aggregator: 7 Boards incl. Remote OK (`deepmine/remote-jobs-aggregator`) Actor

Remote jobs scraper for 7 job boards at once: Himalayas, Remote OK (open posts, not just its API), We Work Remotely, Jobicy, Relomote, Arbeitnow, Working Nomads. Filter by keyword, category, country, date. Title, company, location, job type, links, description, plus salary and logo when listed.

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

## Pricing

from $0.98 / 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 Aggregator: 7 Boards incl. Remote OK

Remote jobs scraper for 7 boards: Himalayas, Remote OK (its open posts, not just its ~100-job API), We Work Remotely, Jobicy, Relomote, Arbeitnow and Working Nomads. Type a keyword like python or customer support and get one list of remote jobs, shared out across the boards, with title, company, location, job type, posted date, apply link, description and the salary when the job lists one.

| 💼 Title | 🏢 Company | 📍 Location | 🕒 Job Type | 💰 Salary | 📅 Posted | 📋 Boards |
|---|---|---|---|---|---|---|
| Senior Applied AI/ML Scientist | NobleAI | United States | Full-time | USD 190,000 - 220,000 per year | 2026-10-01 | Himalayas |
| Senior Customer Success Manager | 1Password | United Kingdom | Full-time | GBP 73,000 - 106,000 per year | 2026-10-01 | Jobicy |
| Senior Software Engineer, Card Authorization | Lithic | Anywhere | Full-time | – | 2026-09-30 | We Work Remotely |

<sub>Collected 2026-10-01.</sub>

**$0.98 per 1,000 jobs** on every plan (Free, Starter, Scale and Business). The prefilled run (up to 100 jobs: 50 python and 50 customer support jobs of the last 7 days) costs about $0.10.

It reads the boards' public job feeds and pages at run time: no login, no browser. The prefilled run with a $0.05 spending limit on 2026-10-01 (build 0.1.33) found 201 matching jobs and delivered the 51 that $0.05 pays for, from all 7 boards: Himalayas 13, Jobicy 13, We Work Remotely 12, Relomote 8, Remote OK 2, Arbeitnow 2 and Working Nomads 1 (Remote OK, Arbeitnow and Working Nomads post few new remote jobs a week). 6 of the 8 Relomote jobs link the employer's own apply page. The first job was in the dataset 7 seconds after the run was started, and the run took 41 seconds.

### What you can do with it

- **Find remote work in one place**: one search covers seven remote job boards, with a job listed on several boards shown once.
- **Feed a job board, newsletter or Slack channel** with fresh remote jobs: schedule it daily with `postedWithinDays` set to 2.
- **Filter by where you live**: `Open to candidates in` keeps the jobs open to your country, including worldwide jobs and jobs for your region (Europe, LATAM, APAC, North America).
- **Benchmark remote pay**: the **💰 With Salary** list holds every job with a published salary, with numbers you can sort and average.
- **Track who's hiring remotely** for a skill or role, by company and category.

### Input

```json
{
  "keywords": ["python", "customer support"],
  "categories": ["Software Development", "Customer Support"],
  "country": "Germany",
  "postedWithinDays": 7,
  "maxJobsPerKeyword": 100
}
```

| Field | What it does |
|---|---|
| `keywords` | What to search for, one per line: a skill, role or tool (python, product designer, customer support, react). A job matches when every word is in its title, company, or the board's own category and tags, as whole words (java doesn't find JavaScript). A skill or tool (python, kubernetes, machine learning) also matches when the whole phrase is in the description. Words that name a kind of job (sales, design, marketing, data, customer support, product manager) and short keywords of 1 to 3 letters (ai, go, qa) match the title, category and tags only, since nearly every description mentions them. When `maxJobsPerKeyword` cuts, title matches go first, then category and tag matches, then description matches, and within each the boards take turns, so one busy board can't fill the cap. An empty list gives the latest remote jobs of every kind. |
| `categories` | Optional. Keep only jobs in these categories: Software Development, Data & AI, DevOps & IT, Design, Product, Marketing, Sales, Customer Support, Finance & Legal, HR & Recruiting, Writing & Content, Operations, Other. Each board's own category is mapped to these. |
| `country` | Optional (`Open to candidates in` in the form). A country you live in, e.g. United States, Germany, India, Brazil. Keeps the jobs open to its residents: jobs that name the country or its region, and jobs open worldwide. `Worldwide` keeps only the jobs open to anyone, anywhere. |
| `postedWithinDays` | Keep only jobs posted in the last N days (0 = any date). Older jobs cost nothing. |
| `maxJobsPerKeyword` | The jobs to keep per keyword, across all boards: the best matches, shared out so each board with matches gets its turn (Himalayas alone posts hundreds of jobs a day and would otherwise fill it), newest first in the dataset (default 100; the form starts at 50). 0 = every job the boards give. You pay per job, so this caps the cost per keyword. |
| `boards` | Which boards to search: `himalayas`, `jobicy`, `remoteok`, `weworkremotely`, `workingnomads`, `arbeitnow`, `relomote` (all seven by default). 4 Day Week is no longer searched: its jobs' apply links need a paid 4dayweek.io account (an input that names `fourdayweek` still runs, without it). |
| `employmentTypes` | More filters. Keep only these job types: Full-time, Part-time, Contract, Temporary, Internship. Jobs whose board and title don't give a type are left out. |
| `seniority` | More filters. Keep only these levels: Entry-level, Mid-level, Senior, Manager, Director, Executive. Himalayas and Jobicy give a level; for the other boards only a clear title word counts (Senior, Lead, Junior, Director, VP). |
| `minSalary` | More filters. Keep only jobs listing a US-dollar salary whose top of range is at least this per year (hourly and monthly pay converted). Jobs with no salary or another currency are left out. |
| `timezone` | More filters. A UTC offset you work in (UTC-5, UTC+1, UTC+5:30). Keeps Himalayas jobs that accept it (the only board that lists time zones) and, from the other boards, only jobs open worldwide. |
| `maxResults` | Advanced. Stop after this many jobs in total (default 1,000). |
| `includeDescription` | Advanced. Full description as plain text (on by default, same price). |
| `includeDescriptionHtml` | Advanced. Also the description as HTML, in `descriptionHtml` (off by default, same price). |
| `findContactEmails` | Advanced. For jobs whose description gives no email, look for one on the company's own website: its home page, then its contact, careers or about page. Only an address on the company's own domain counts. The website is the one We Work Remotely lists, or the company's name as a domain (acme.com, acme.io, acme.ai) when that site's title carries the company's name. Off by default; charged per job that gets an email this way (see Pricing). In two test runs on 2026-10-01 (the prefill with a $0.05 limit), 4 to 7 of about 45 jobs got one from a website and 6 to 7 from their description, mostly general or accessibility inboxes (info@, contact@, accommodations@) rather than careers@. It makes a run slower, since a slow company site can take 20 s: those runs (build 0.1.24) took 77 s and 157 s, against 22 s for the same search without it. |
| `proxyConfiguration` | Advanced. Apify Proxy (datacenter) by default; the feeds are public, so it only spreads the requests over several IPs. Residential and SERP proxies are replaced with datacenter. |

### Output

One row per job. Rows go out as the boards answer, so the first jobs are in the dataset within seconds: for each keyword, the boards that answer within a second of the first one go out together, newest first, and a slower board's jobs follow as soon as it answers. A job that several boards list comes once: when those boards answer together, its fields come from the richest board (Himalayas, then Jobicy, Remote OK, We Work Remotely, Working Nomads, Arbeitnow, Relomote) and `sources` / `sourceUrls` list every board with the job's page there; a board that answers after the job's row went out isn't added to it (OUTPUT counts these). A job that several keywords find comes once, under the first keyword that found it.

Two datasets, both with the same rows:

- **💼 All Jobs** (default dataset). Views: **📊 Overview** (🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 🕒 Job Type, 🗂️ Category, 💰 Salary, 📅 Posted, 📋 Boards, 🔗 Job Page) and **📝 Details** (💼 Title, 🏢 Company, 🎚️ Seniority, 🌍 Worldwide, 🗺️ All Locations, 🕐 Time Zones, 💰 Salary Min, 💰 Salary Max, ⏱️ Pay Period, ⌛ Expires, 📝 Apply, 🔗 Board Links, 🔍 Keywords, 🆔 Job ID) and **📇 Contacts** (🖼️ Logo, 💼 Title, 🏢 Company, 📧 Contact Email, 📧 Email Source, 🌐 Website, 🏢 Company Page, 📝 Apply, 🔗 Job Page).
- **💰 With Salary**: the delivered jobs that publish a salary, in the same order, at no extra charge. View **💰 Salaries**: 🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 💰 Salary, 💰 Salary Min, 💰 Salary Max, 💱 Currency, ⏱️ Pay Period, 📅 Posted, 🔗 Job Page.

#### Output fields

In row order:

- `companyLogo`: the company's logo from the board (Himalayas, Jobicy, Remote OK, Relomote and some We Work Remotely jobs; Arbeitnow and Working Nomads show none).
- `title`: job title.
- `company`: company name.
- `location`: where a hire may live, in short: `Anywhere`, `United States`, `Europe, United Kingdom`, or `Albania, Andorra, Argentina + 70 more` for a long list.
- `isWorldwide`: `true` when anyone anywhere can apply, `false` when the board names places, empty when it doesn't say.
- `employmentType`: `Full-time`, `Part-time`, `Contract`, `Temporary`, `Internship` or `Volunteer`.
- `seniority`: `Entry-level`, `Mid-level`, `Senior`, `Manager`, `Director` or `Executive`, when the board says (Himalayas, Jobicy, some Remote OK and Arbeitnow jobs). A Himalayas job open to two levels lists both (`Mid-level, Senior`).
- `category`: the board's category in common words (see `categories` above).
- `salary`: published pay, e.g. `USD 160,000 - 200,000 per year`. Empty when the job lists none (18 of 51 jobs had one in the prefilled run on 2026-10-01; We Work Remotely lists none).
- `salaryMin`: the lowest pay in the range, as a number.
- `salaryMax`: the highest pay in the range, as a number.
- `salaryCurrency`: ISO currency code, e.g. `USD`, `EUR`.
- `salaryPeriod`: `year`, `month`, `2 weeks`, `week`, `day` or `hour`.
- `postedAt`: when the job was published on the board, in UTC (`2026-09-30T15:08:46Z`). For Arbeitnow it's the date on the job's own page: its feed's date is when it last refreshed the listing, often weeks later, so it's never used. Empty when the board gives no date.
- `expiresAt`: when the board takes the listing down, in UTC (Himalayas, We Work Remotely, Remote OK, Arbeitnow, Relomote).
- `jobUrl`: the job's page on its first board.
- `applyUrl`: where to apply: for Relomote jobs, the employer's own page its Apply button opens (Greenhouse, Ashby, Workday, Workable...); for the other boards, the employer's own link when a description gives one (an applicant tracking system or form), else the board's apply page (Working Nomads' sends you on to the employer; We Work Remotely and Jobicy ask you to sign in to apply). A link a description offers for accommodation, accessibility or privacy requests is never taken as the apply link.
- `contactEmail`: a contact email for the job: from a description (a hiring mailbox such as jobs@ or recruiting@ first), or with `findContactEmails` from the company's website. Empty when neither gives one, which is most jobs (4 to 14 of 51 in the prefilled runs on 2026-10-01 had one from a description, often a general or accessibility inbox).
- `contactEmailSource`: the page the email was found on: the job's page, or a page of the company's website.
- `companyWebsite`: the company's own website (We Work Remotely lists it for about a third; with `findContactEmails`, also the site the search confirmed). Empty otherwise.
- `companyUrl`: the company's page on the board (Himalayas, Remote OK, Relomote).
- `locations`: every country or region the board lists. Empty when the job is open anywhere or the board doesn't say.
- `timezones`: UTC offsets a hire must work in (`UTC-5`), or `Any`. Himalayas lists them.
- `tags`: skills and tags from Remote OK, We Work Remotely, Working Nomads and Arbeitnow (`Python`, `Django`), or Himalayas' own role labels (`Data Engineer`, `Staff Data Engineer`, not skills) when no other board lists the job. Jobicy and Relomote give none.
- `boardCategory`: the board's own category name as it prints it (`Developer`, `Sales and Marketing`); for Remote OK its industry (`Startups`).
- `description`: the full job description as plain text, `•` for list items. Only with `includeDescription` (on by default).
- `descriptionHtml`: the board's description as HTML. Only with `includeDescriptionHtml`.
- `sources`: every board that lists the job, the row's own board first.
- `sourceUrls`: the job's page on each of those boards, same order.
- `jobId`: the job's id on its first board.
- `keywords`: your keywords that found the job. Empty for a run without keywords.
- `scrapedAt`: when this run read the job (UTC).

Example row (with `findContactEmails` and `includeDescriptionHtml` on; lists and description shortened):

```json
{
  "companyLogo": "https://cdn-images.himalayas.app/95gzgg20hqvtq04pae5z2598mdmo",
  "title": "Sr. Security Researcher",
  "company": "Crowdstrike",
  "location": "United States",
  "isWorldwide": false,
  "employmentType": "Full-time",
  "seniority": "Senior",
  "category": "Software Development",
  "salary": "USD 85,000 - 120,000 per year",
  "salaryMin": 85000,
  "salaryMax": 120000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedAt": "2026-10-01T01:33:24Z",
  "expiresAt": "2026-11-30T01:33:23Z",
  "jobUrl": "https://himalayas.app/companies/crowdstrike/jobs/sr-security-researcher-1862189292",
  "applyUrl": "https://himalayas.app/companies/crowdstrike/jobs/sr-security-researcher-1862189292",
  "contactEmail": "info@crowdstrike.com",
  "contactEmailSource": "https://crowdstrike.com/en-us/contact-us/",
  "companyWebsite": "https://crowdstrike.com/",
  "companyUrl": "https://himalayas.app/companies/crowdstrike",
  "locations": ["United States"],
  "timezones": ["UTC-10", "UTC-9", "UTC-8", "UTC-7", "UTC-6", "UTC-5"],
  "tags": ["Security Researcher", "Threat Intelligence Analyst", "Vulnerability Researcher", "Malware Analyst"],
  "boardCategory": "Developer",
  "description": "As a global leader in cybersecurity, CrowdStrike protects the people, processes and technologies that drive modern organizations. Since 2011, our ...",
  "descriptionHtml": "<p>As a global leader in cybersecurity, CrowdStrike protects the people, processes and technologies that drive modern ...",
  "sources": ["Himalayas"],
  "sourceUrls": ["https://himalayas.app/companies/crowdstrike/jobs/sr-security-researcher-1862189292"],
  "jobId": "crowdstrike/sr-security-researcher-1862189292",
  "keywords": ["python"],
  "scrapedAt": "2026-10-01T01:58:41Z"
}
```

The run's **🧾 Run summary** (the OUTPUT record in the key-value store) shows, per keyword and board, how many jobs the board sent and how many matched, plus any error.

### Credit the boards

The boards share their jobs on the condition that you credit them: keep each job's `sourceUrls` (a link back to the original posting) and name the board in `sources` when you show the jobs to others. Remote OK asks for a followed link and the name "Remote OK" (not its logo); Arbeitnow asks for a link back to its site. Himalayas asks that its jobs aren't submitted to third-party job sites such as Google Jobs, LinkedIn Jobs or Jooble.

### When something goes wrong

- If a board doesn't answer after several retries on fresh IPs, the run still delivers the other boards' jobs and says which board failed in the status message and the run summary. If no board answers at all, or a board fails and the others find nothing, the run ends as **failed** so you notice.
- If a board answers in a format we can't read (a changed feed), that board counts as failed in the same way, with the reason in the run summary (`boardsChangedFormat`, `boardErrors`), instead of quietly giving fewer jobs.
- If a board asks us to slow down (HTTP 429), the run waits as long as the board asks and tries again from the same IP.
- A keyword no board has jobs for gives a clean empty result and a status message saying so. The status message says a board "had no matching job" only when it answered every search; a board your spending limit or `maxResults` stopped before it answered is named as not having answered.
- When `maxResults` or your spending limit is reached, the run stops there, after delivering every job the limit pays for (the prefilled run with a $0.05 limit delivered 51 jobs at $0.98 per 1,000); you pay only for the jobs delivered.

### Pricing

You pay per job delivered: $0.98 per 1,000 jobs on every plan (Free, Starter, Scale and Business). Descriptions, salaries, apply links and the emails job descriptions give are included at the same price. No start fee. With `findContactEmails` on, a job that gets its contact email from the company's website adds $0.98 per 1,000 such jobs (on every plan); a job without one adds nothing. Requests, retries, jobs left out by your filters and the 💰 With Salary list cost nothing.

Examples: the prefilled run (up to 100 jobs) about $0.10; the default `maxResults` of 1,000 jobs $0.98; 5,000 jobs $4.90. `maxJobsPerKeyword` and `maxResults` cap what a run can cost.

### FAQ

**How many jobs does a keyword reach?** Himalayas' search goes up to 5,000 jobs per keyword, Remote OK the open posts in our index (below), Jobicy its latest 200, We Work Remotely its ten category feeds (about 300 jobs), Relomote the newest 90 fully remote jobs of each matching category in North America and in Europe (its plain category pages are mostly hybrid jobs), Arbeitnow its last few days (about 140 remote jobs) and Working Nomads its latest 60 or so. `maxJobsPerKeyword` keeps the best matches across all of them, each board with matches taking its turn. With no keyword, `maxJobsPerKeyword` 0 and a high `maxResults`, a run takes every job those feeds give.

**How does it read Remote OK's full board?** Remote OK's public API holds only about 100 jobs, days behind the site, and the feed its own page scrolls through is one its robots.txt asks crawlers not to use; we respect robots.txt (the same reason Remotive isn't included). So we read the job pages its robots.txt does allow, one per second as it asks, and keep the open ones in an index that a scheduled run brings up to date every two hours. Remote OK keeps a post's page up after its poster closes it, marked "closed", so each update also reads the indexed jobs checked longest ago again and drops the ones closed since, so a post closed since its last check (at most a few hours) can still come through. The index is still filling with Remote OK's older posts, a few hundred pages per update. Your run reads that index in a second and reads the few Remote OK pages posted since the last update itself. The run summary's `remoteOkFullBoard` shows how many jobs the index held and how old it was.

**How fresh is the data?** Each run reads the boards' feeds at run time, so a job comes in as soon as its board lists it. Remote OK's index is at most about two hours old, and your run adds the Remote OK jobs posted since.

**Can I get new jobs every day?** Yes: save your input as a task, schedule it daily, and set `postedWithinDays` to 2 so each run brings the latest postings. A job two runs find comes in both; dedupe on `jobUrl`.

**Does it collect personal data?** Rows hold jobs and companies, no recruiter profiles. `contactEmail` is the address a job posting or the company's website publishes for applications or inquiries, which can be a recruiter's work email; use it within the privacy and anti-spam rules that apply to you.

### One board only

Need just one board? [Himalayas Jobs](https://apify.com/deepmine/himalayas-jobs-scraper) and [We Work Remotely Jobs](https://apify.com/deepmine/we-work-remotely-jobs-scraper) run this same search on that board alone, with a form and a table made for it.

### Feedback

Missing a board, a field or a filter? Open an issue on the Issues tab and we'll look at it. If the data helped you, a short review on this page helps other people find it.

# Actor input Schema

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

What to search for, one keyword per line: a skill, role or tool (python, product designer, customer support, react). Each keyword is searched on every board you pick. Leave the list empty for the latest remote jobs of every kind. You pay per job delivered.

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

Optional. Keep only jobs in these categories (the boards' own categories, in common words). Leave empty for every category.

## `country` (type: `string`):

Optional. A country you live in (United States, Germany, India, Brazil...): keeps the jobs open to its residents, including jobs open worldwide and jobs for its region (Europe, LATAM, APAC, North America). Type Worldwide for only the jobs open to anyone, anywhere. Leave empty for every job.

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

Keep only jobs posted in the last N days; older ones cost nothing. 0 means any date. Handy for a daily or weekly scheduled run.

## `maxJobsPerKeyword` (type: `integer`):

The jobs to keep per keyword, across all boards: the best matches, each board with matches taking its turn (so one busy board can't fill it). You pay per job, so this caps the cost per keyword. 0 means every job the boards give. Default 100.

## `boards` (type: `array`):

The boards to search. All seven by default. Remote OK is its full live board, not just its API's 100 newest.

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

Optional. Keep only these job types. A job whose board doesn't give its type (and whose title doesn't say, e.g. 'Contract') is left out. Leave empty for every type.

## `seniority` (type: `array`):

Optional. Keep only these levels. Himalayas and Jobicy give a level; for the other boards only a clear title word counts (Senior, Lead, Junior, Director, VP). Jobs with no known level are left out. Leave empty for every level.

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

Optional. Keep only jobs that list a salary in US dollars whose top of range is at least this, per year (hourly and monthly pay are converted). Jobs with no listed salary, or pay in another currency, are left out. 0 means no salary filter.

## `timezone` (type: `string`):

Optional UTC offset you work in, e.g. UTC-5, UTC+1, UTC+5:30. Keeps Himalayas jobs that accept it (the only board that lists time zones) and, from the other boards, only jobs open worldwide.

## `maxResults` (type: `integer`):

Stop after this many jobs in total. You pay per job, so this caps the run's cost.

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

The full job description as plain text. Same price either way; turn it off for smaller rows.

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

Also the board's description as HTML (links and lists kept), in descriptionHtml. Same price; rows get about twice as big.

## `findContactEmails` (type: `boolean`):

For jobs whose description gives no email, look for one on the company's own website (its home, contact and careers pages). Charged per job that gets an email this way; emails a description gives are always included free. Works when the company's website is known (We Work Remotely lists it) or can be confirmed from its name. Slower: test runs of about 45 jobs took 1.5 to 2.5 minutes with it, 22 seconds without.

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

Apify Proxy (datacenter) by default; the boards' feeds are public, so it only spreads the requests over several IPs. Residential and SERP proxies are replaced with datacenter. Turn it off to connect directly.

## Actor input object example

```json
{
  "keywords": [
    "python",
    "customer support"
  ],
  "postedWithinDays": 7,
  "maxJobsPerKeyword": 50,
  "boards": [
    "himalayas",
    "jobicy",
    "remoteok",
    "weworkremotely",
    "workingnomads",
    "arbeitnow",
    "relomote"
  ],
  "minSalary": 0,
  "maxResults": 1000,
  "includeDescription": true,
  "includeDescriptionHtml": false,
  "findContactEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `withSalaryUrl` (type: `string`):

No description

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

No description

# 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": [
        "python",
        "customer support"
    ],
    "postedWithinDays": 7,
    "maxJobsPerKeyword": 50,
    "boards": [
        "himalayas",
        "jobicy",
        "remoteok",
        "weworkremotely",
        "workingnomads",
        "arbeitnow",
        "relomote"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/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": [
        "python",
        "customer support",
    ],
    "postedWithinDays": 7,
    "maxJobsPerKeyword": 50,
    "boards": [
        "himalayas",
        "jobicy",
        "remoteok",
        "weworkremotely",
        "workingnomads",
        "arbeitnow",
        "relomote",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/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": [
    "python",
    "customer support"
  ],
  "postedWithinDays": 7,
  "maxJobsPerKeyword": 50,
  "boards": [
    "himalayas",
    "jobicy",
    "remoteok",
    "weworkremotely",
    "workingnomads",
    "arbeitnow",
    "relomote"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/remote-jobs-aggregator --silent --output-dataset

```

## MCP server setup

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