# Remote Jobs by Country: Himalayas, RemoteOK, WWR, Jobicy (`quietbyte/remote-jobs-by-country`) Actor

Remote jobs from Himalayas, Remote OK, We Work Remotely and Jobicy in one deduplicated feed. Enter the country you work from and get only jobs open to it (worldwide, region or country lists, time zones), each tagged for visa sponsorship and relocation. Monitoring mode: pay only for new jobs.

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

## Pricing

$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 by Country: Himalayas, Remote OK, We Work Remotely, Jobicy

Remote jobs from **Himalayas, Remote OK, We Work Remotely and Jobicy** in one deduplicated feed, with a filter for the question every international remote job seeker asks:

> **"Can I actually apply from where I live?"**

Enter the country you work from and get only jobs open to it: worldwide roles, region lists (`APAC`, `EMEA`, `LATAM`…), country lists and time-zone limits are all read for you. Every job also carries visa-sponsorship and relocation tags, so it suits job seekers, remote-job boards, recruiters and AI agents.

### Why eligibility matters

Most "remote" jobs are not open to everyone. In a sample of 200 recent Jobicy jobs, **118 were open to US residents only**. Boards describe this in different ways: an empty country list on one, `APAC, EMEA, USA` on another, a list of 70 flags on a third, a time-zone range on a fourth. This Actor reads all of them into the same fields:

- **`worldwide`**, **`eligibleRegions`**, **`eligibleCountries`**, **`excludedCountries`** and **`timezones`**: what the job allows.
- **`openToApplicant`**: `yes`, `no` or `unclear` for the country you entered (`null` if you entered none).
- **`eligibilityBasis`** and **`eligibilityEvidence`**: where that came from. `listing` means the board's own location fields. `description` means a sentence in the ad that says where the person must live (shown in full). `none` means neither says.

### What you can put in

| Input | What it does |
|---|---|
| `applicantCountry` | ISO code (`PL`) or name (`Poland`). Adds `openToApplicant` to every job and drives the filter below. |
| `eligibilityMode` | `open_or_unclear` (default) keeps `yes` and `unclear`. `open_to_me` keeps only `yes`. `all` keeps everything and only adds the tag. |
| `applicantUtcOffset` | For example `1`, `-5` or `5.5`. Drops jobs that only hire in other time zones (Himalayas lists them). |
| `worldwideOnly` | Keep only jobs open anywhere in the world. |
| `keywords` | Whole-word match on the title, or on the description too with `keywordsMatchDescription`. |
| `sources` | Any of Himalayas, Jobicy, Remote OK, We Work Remotely (all four by default). |
| `employmentTypes` | `full_time`, `part_time`, `contract`, `internship`, `temporary`. A job whose type the board doesn't say still passes. |
| `postedWithinDays` | Only jobs posted in the last N days. |
| `visaFilter` | `offered` keeps ads that offer sponsorship; `not_refused` drops ads that rule it out. |
| `addVisaTags`, `includeDescription` | Turn the visa tags and the full description on or off. Same price either way. |
| `maxJobsPerSource`, `maxResults` | Limits. `maxJobsPerSource` caps how many jobs are read from a board before filters apply. |
| `onlyNewJobs`, `monitorName` | Monitoring mode, below. |

#### Example input

```json
{
  "keywords": ["engineer", "developer"],
  "applicantCountry": "PL",
  "applicantUtcOffset": "1",
  "eligibilityMode": "open_or_unclear",
  "postedWithinDays": 14
}
```

### What you get

A real record (description shortened):

```json
{
  "id": "jobicy:154567",
  "jobKey": "b8175656541e9e2b",
  "source": "jobicy",
  "sourceName": "Jobicy",
  "title": "Senior Software Engineer, Internal Tooling",
  "company": "RevenueCat",
  "location": "APAC, EMEA, USA",
  "employmentType": "full_time",
  "seniority": [
    "Senior"
  ],
  "categories": [
    "DevOps & Infrastructure"
  ],
  "postedAt": "2026-10-05",
  "expiresAt": null,
  "salary": {
    "min": 230000.0,
    "max": 230000.0,
    "currency": "USD",
    "interval": "year",
    "text": null
  },
  "url": "https://jobicy.com/jobs/154567-senior-software-engineer-internal-tooling",
  "applyUrl": "https://jobicy.com/jobs/154567-senior-software-engineer-internal-tooling",
  "worldwide": false,
  "eligibleCountries": [
    "US"
  ],
  "eligibleRegions": [
    "APAC",
    "EMEA"
  ],
  "excludedCountries": [],
  "timezones": [],
  "eligibilityBasis": "listing",
  "eligibilityEvidence": "APAC, EMEA, USA",
  "openToApplicant": "yes",
  "visaSponsorship": "not_mentioned",
  "visaEvidence": [],
  "relocationOffered": false,
  "relocationEvidence": null,
  "description": "RevenueCat gives app businesses the infrastructure and tools to build, run, and improve th…",
  "alsoListedOn": [],
  "attribution": "Job from Jobicy (jobicy.com). If you republish it, credit Jobicy with a direct link and send applicants to the url.",
  "scrapedAt": "2026-10-08T13:43:16+00:00"
}
```

**Field notes**

- **`openToApplicant`:** `yes` / `no` / `unclear` for your country. In the record above the job lists `EMEA`, so a person in Poland gets `yes`.
- **Why Remote OK often says `unclear`:** most Remote OK posts have an empty or one-word location ("Remote"). The Actor then looks for a sentence in the ad such as "you must be based in Europe". When there is none, the answer is `unclear` rather than a guess. Use `open_to_me` if you only want clear matches.
- **`timezones`:** UTC offsets a job lists (Himalayas). A list that covers every time zone is treated as no restriction.
- **`alsoListedOn`:** the same job (same company and title) on other boards. You get one record, from the board that describes it best, and the other links here.
- **`attribution`:** the credit each board asks for (see below).
- **Run summary:** the run's key-value store has a `SUMMARY` record with, per board, how many jobs were read, how many passed the filters, how many were saved, and any problem.

### Daily monitoring: pay only for new jobs

Turn on **Only jobs new since the last run** and schedule the Actor daily. It remembers the jobs it has returned (per **monitor name**, or per exact set of filters), including jobs seen on another board, so after the first run you only get, and only pay for, new postings. Each new job has `"isNew": true`.

### Pricing

Pay per event: you pay only for jobs you receive.

| Event | Price |
|---|---|
| Remote job (visa and relocation tags included) | $1.50 per 1,000 jobs |

Jobs that don't match your filters and duplicates cost nothing. Runs stop cleanly at your spending limit.

### Using these jobs on your own site

Each board allows its jobs to be used on other sites if you credit it. The `attribution` field on every job says how:

- **Himalayas:** link back to the job's `url` and credit Himalayas. Don't submit Himalayas jobs to Jooble, Neuvoo, Google Jobs or LinkedIn Jobs.
- **Jobicy:** credit Jobicy with a direct link, and send applicants to the job's `url`. Schedule runs no more than once an hour.
- **Remote OK:** link back to the `url` with a followed link and mention Remote OK. Don't use the Remote OK logo (this Actor never returns logos).
- **We Work Remotely:** attribute the link back to We Work Remotely.

### Data sources and compliance

- **Sources:** each board's own free public API or RSS feed, used within the terms it publishes. No logins, no proxies, no browser automation.
- **No personal data:** employer job ads only. Email addresses inside descriptions are replaced with `[email removed]`, and no company logos are copied.
- **Not included:** Remotive (its terms cap use at 4 calls a day), LinkedIn, Indeed and other sites that only offer scraping.

### Limits

- **Remote OK** returns its newest 100 jobs.
- **Jobicy** covers the last 7 days, with a delay of about 3 hours.
- **We Work Remotely** feeds hold the latest jobs in each category (about 380 in total).
- **Himalayas** returns 20 jobs per request and is rate-limited, so large pulls are slower.

### FAQ

**How accurate is `openToApplicant`?**
It is rule-based and cautious. Every answer comes with its evidence, and when a job doesn't say where it hires, the answer is `unclear`, not a guess. Treat `yes` as a strong lead and read the ad before you apply.

**Can I use it from an AI agent or over MCP?**
Yes. It's a standard Apify Actor, so any Apify client, the Apify API or Apify's MCP server can call it.

**Why is a job `unclear`?**
Neither the board's location fields nor the ad text say where the employer hires. Set `eligibilityMode` to `open_to_me` to hide those jobs.

### Related Actors

- [ATS Jobs API with Visa Sponsorship Tags](https://apify.com/quietbyte/ats-jobs-visa): jobs on company career boards (Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee) with sentence-level visa tags.
- [Workday Jobs API with H-1B & UK Visa Sponsor Evidence](https://apify.com/quietbyte/workday-jobs-visa): any Workday careers site, with visa tags backed by the employer's US H-1B filings and UK sponsor licence.
- [Podcast Transcripts from RSS](https://apify.com/quietbyte/podcast-transcripts): publisher-provided transcripts as text, timestamped Markdown or RAG chunks.

# Actor input Schema

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

Keep jobs whose title contains any of these words or phrases (case-insensitive, whole words). Leave empty for all jobs.

## `keywordsMatchDescription` (type: `boolean`):

Also search the job description, not just the title.

## `applicantCountry` (type: `string`):

ISO code (PL) or name (Poland). Keeps jobs open to people living there.

## `applicantUtcOffset` (type: `string`):

e.g. 1 or -5 or 5.5. Drops jobs that only hire in other time zones (Himalayas lists them).

## `eligibilityMode` (type: `string`):

Only used when a country is set. "Open to me" keeps jobs clearly open to your country. "Open or unclear" also keeps jobs that don't say where they hire (Remote OK often doesn't). "All" keeps everything and only adds the openToApplicant tag.

## `worldwideOnly` (type: `boolean`):

Keep only jobs open to applicants anywhere in the world.

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

Which boards to read.

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

Keep only these types. A job whose type the board doesn't say still passes. Leave empty for all.

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

Keep jobs posted in the last N days. 0 = no limit.

## `addVisaTags` (type: `boolean`):

Reads every job ad sentence by sentence and adds visaSponsorship (offered / refused / mixed / not_mentioned) with the sentence it's based on, and relocationOffered. Same price either way.

## `visaFilter` (type: `string`):

"offered" keeps only jobs whose ad offers visa sponsorship. "not_refused" drops jobs whose ad rules it out. Turns on the tags automatically.

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

Add the full plain-text job description to each result. Email addresses in descriptions are removed.

## `maxJobsPerSource` (type: `integer`):

Stop reading a board after this many jobs (before filters are applied).

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

Stop the whole run after this many jobs. 0 = no limit (your run's spending limit still applies).

## `onlyNewJobs` (type: `boolean`):

Remember which jobs were already returned (also across boards) and output only new ones. Ideal for a daily schedule: you pay only for new jobs. The first run returns everything.

## `monitorName` (type: `string`):

Optional. Runs with the same monitor name share one memory of seen jobs. If empty, the memory is tied to this exact set of filters.

## Actor input object example

```json
{
  "keywords": [
    "engineer"
  ],
  "keywordsMatchDescription": false,
  "applicantCountry": "PL",
  "applicantUtcOffset": "",
  "eligibilityMode": "open_or_unclear",
  "worldwideOnly": false,
  "sources": [
    "himalayas",
    "jobicy",
    "remoteok",
    "weworkremotely"
  ],
  "employmentTypes": [],
  "postedWithinDays": 0,
  "addVisaTags": true,
  "visaFilter": "any",
  "includeDescription": true,
  "maxJobsPerSource": 200,
  "maxResults": 0,
  "onlyNewJobs": false,
  "monitorName": ""
}
```

# Actor output Schema

## `results` (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": [
        "engineer"
    ],
    "applicantCountry": "PL"
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietbyte/remote-jobs-by-country").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"],
    "applicantCountry": "PL",
}

# Run the Actor and wait for it to finish
run = client.actor("quietbyte/remote-jobs-by-country").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"
  ],
  "applicantCountry": "PL"
}' |
apify call quietbyte/remote-jobs-by-country --silent --output-dataset

```

## MCP server setup

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

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/9vuagH4BiLzY8mbI9/builds/9CXTdz0x65kQxILfL/openapi.json