# RemoteOK Jobs Scraper (`zilicon/remote-jobs-scraper`) Actor

Scrape remote jobs from RemoteOK and WeWorkRemotely and get title, company, region, category, tags, salary, posting date and apply URL. Both boards in one run, de-duplicated, filtered by keyword, tag or region. No login, no account.

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

## Pricing

$3.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Scrape remote jobs from RemoteOK and WeWorkRemotely

Pull remote job postings from **RemoteOK** and **WeWorkRemotely** in a single run, de-duplicated across both, as clean flat JSON.

Each record carries title, company, region, category, skill tags, salary where the board publishes it, posting date and a direct apply URL. No login, no API key, no CAPTCHA.

**Get your first results in about 20 seconds:** press **Start** with the prefilled input. It returns about 60 engineering jobs drawn from both boards. Then change the keywords, add a region, or filter by tag.

When a result cap is smaller than what the boards return, the two feeds are interleaved rather than read in order, so a cap is shared evenly instead of being filled entirely by whichever board is listed first.

Your **$5 of free Apify credit is worth roughly 1,670 job records** on this actor.

#### What you get per job

| Field | Description |
|---|---|
| `id` | Stable id, board-prefixed - e.g. `remoteok:1135758` |
| `board` | `remoteok` or `weworkremotely` |
| `title` | Job title |
| `company` | Hiring company |
| `location` | Region as the board states it - e.g. `Anywhere in the World`, `Remote`, `California` |
| `category` | Job category - published by WeWorkRemotely |
| `tags` | Skill and role tags - RemoteOK's main classification |
| `salaryMin`, `salaryMax` | Annual range when the board publishes one - see the coverage note below |
| `url`, `applyUrl` | The public posting and its apply page |
| `publishedAt` | ISO 8601 posting date |
| `teaser` | First 300 characters of the description, HTML stripped |

#### Sample record

```json
{
  "id": "remoteok:1135739",
  "board": "remoteok",
  "title": "Product Engineer",
  "company": "SuperPlane",
  "location": "Remote",
  "category": null,
  "tags": ["golang", "javascript", "react", "ai"],
  "salaryMin": 60000,
  "salaryMax": 90000,
  "url": "https://remoteOK.com/remote-jobs/remote-product-engineer-superplane-1135739",
  "applyUrl": "https://remoteOK.com/remote-jobs/remote-product-engineer-superplane-1135739",
  "publishedAt": "2026-07-31T14:48:13+00:00",
  "teaser": "About SuperPlane SuperPlane is an open source software factory engine: the system that lets AI agents build, test, and ship code while engineers focus on design and decisions..."
}
```

### Filters

| Input | What it does |
|---|---|
| `keywords` | Keep jobs containing ALL of these words, e.g. `react senior` |
| `maxResults` | Stop after this many jobs. Your cost control |
| `boards` | Which boards to pull. Both by default |
| `titleOnly` | Match the keywords against the job title alone |
| `excludeKeywords` | Drop jobs containing ANY of these words, e.g. `intern crypto` |
| `location` | Keep jobs whose region contains this text, e.g. `Europe`, `USA` |
| `category` | Keep a single category, e.g. `Programming` - WeWorkRemotely |
| `tags` | Keep jobs carrying ANY of these tags, e.g. `python`, `react` - RemoteOK |
| `minSalary` | Keep jobs advertising at least this annual figure |
| `postedWithinDays` | Keep only jobs published in the last N days |
| `maxPerBoard` | Cap how many jobs any one board contributes |
| `proxyConfiguration` | Standard Apify proxy input. Datacenter proxies are fine here |

Neither board offers a server-side search: RemoteOK publishes a JSON feed of its recent postings and WeWorkRemotely an RSS feed. Every filter above is therefore applied to the postings after fetching, not sent as a live query. That costs you nothing extra, and filtering before results are written means you are only charged for the jobs you asked for.

#### A note on region filtering

Most postings on these feeds are genuinely open worldwide - `Anywhere in the World` accounts for roughly half of a full sweep - and the rest carry a specific place rather than a bloc, such as `California`, `Oregon` or `Madrid`. Filter on a country or city name; broad terms like `Europe` or `USA` are not values these boards use and will return nothing.

#### A note on salary coverage

Salary is thinly published on these boards: roughly **2 postings in 100** on RemoteOK carry a figure, and WeWorkRemotely's RSS feed carries none at all. Setting `minSalary` therefore returns very few rows, because postings with no published salary are excluded when a floor is set. Leave it at 0 unless a salary figure is the point of the run.

#### A note on feed depth

Both feeds are a rolling window of recent postings rather than a full archive, so a run returns what the board is currently publishing. Schedule the actor daily if you want to accumulate history.

### What it costs

Pricing is **pay-per-event** on Apify's built-in per-result event: you pay per job returned and nothing at all for a run that finds no matches. There is **no per-run start fee**, so a daily run costs the same as one big monthly pull of the same rows.

A worked example: a full sweep of both feeds with no filter returns about 200 jobs as this is written, which costs roughly **$0.60**. Running that every day for a month is about **$18**. Feed depth moves, so treat the record count as an order of magnitude rather than a quote.

### Typical uses

- **Remote job boards and aggregators** - keep a live feed without maintaining two scrapers.
- **Talent sourcing** - see which distributed companies are hiring, and for which stacks.
- **Market research** - track remote hiring volume by tag, region and category over time.
- **Newsletters and communities** - a filtered daily digest for a specific stack or region.

### Your feedback

If a board is missing, a field is wrong, or you need something these feeds publish that this actor does not yet return, please open an issue on the **Issues** tab. Requests get read and acted on, and a short review helps other people find the actor.

### Source attribution

Job data in this actor's RemoteOK results comes from [Remote OK](https://remoteok.com), and RemoteOK's public API asks that anyone using it credit the source with a followable link back. **If you republish or display these listings, keep that attribution**: credit Remote OK as the source and link to [remoteok.com](https://remoteok.com) without `nofollow`. WeWorkRemotely results likewise link back to the original posting in every record.

#### A note on description text

RemoteOK appends a standard anti-spam block to the end of every job description, containing a code word and the calling client's own IP address in encoded form. That block is not part of the employer's advert, so this actor removes it - your `teaser` field carries the employer's text and does not leak the IP address the run was made from.

### Disclaimer

This is an **unofficial** scraper. It is not affiliated with, endorsed by, or sponsored by RemoteOK or WeWorkRemotely. It reads only data that those boards publish publicly, with no login and no access to private accounts.

#### Personal data in the output

Results may contain personal data (for example a named contact on a job posting). Personal data is protected by regulations such as the GDPR in the EU and the CCPA in California. You should not scrape or process personal data unless you have a legitimate reason to do so; if you are unsure whether your reason is legitimate, consult your lawyers.

# Actor input Schema

## `keywords` (type: `string`):

Keep only jobs containing ALL of these words, e.g. 'react senior'. Matched against the title, company, tags, category and description unless 'Match title only' is on. Leave blank to return the whole feed.

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

Stop after this many jobs. Your cost control - 500 results costs about $1.50. Set 0 for no cap.

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

Which remote-job boards to pull. Both are scraped in one run by default and results are de-duplicated across them.

## `titleOnly` (type: `boolean`):

Match the keywords against the job title alone. Use this when a word appears in the body of nearly every posting and you only want jobs actually named for it.

## `excludeKeywords` (type: `string`):

Drop any job containing ANY of these words, e.g. 'intern manager crypto'. Applied to the whole record.

## `location` (type: `string`):

Keep only jobs whose location or region contains this text, e.g. 'Anywhere', 'California', 'Madrid'. Use a country or city name - the boards do not use bloc terms like 'Europe' or 'USA', so those return nothing.

## `category` (type: `string`):

Keep only jobs whose category contains ALL of these words, e.g. 'Programming', 'Design', 'Customer Support'. Published by WeWorkRemotely; RemoteOK classifies by tags instead, so use Tags for it.

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

Keep jobs carrying ANY of these tags, e.g. 'python', 'react', 'senior'. Matched as substrings against the board's own tag list.

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

Keep only jobs advertising at least this annual figure. Note the coverage: roughly 2 in 100 RemoteOK postings publish a salary and WeWorkRemotely's feed publishes none, so setting a floor returns few rows. Jobs with no published salary are excluded when this is set. Leave 0 to ignore salary.

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

Keep only jobs published in the last N days, e.g. 3 for the last few days. Jobs with no usable date are kept rather than silently dropped. Leave 0 for no date limit.

## `maxPerBoard` (type: `integer`):

Cap how many jobs come from any single board, so one feed cannot fill your whole result set. Leave 0 for no per-board cap.

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

Proxy configuration. Datacenter proxies are fine for these boards.

## Actor input object example

```json
{
  "keywords": "engineer",
  "maxResults": 100,
  "boards": [
    "remoteok",
    "weworkremotely"
  ],
  "titleOnly": false,
  "minSalary": 0,
  "postedWithinDays": 0,
  "maxPerBoard": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every job returned by the run, as rows in the default dataset.

# 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"
};

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

# Run the Actor and wait for it to finish
run = client.actor("zilicon/remote-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
}' |
apify call zilicon/remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zilicon/remote-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/XwDXuh348MzXDLrH7/builds/4ZUFmMUOTjpOKCBLf/openapi.json