# Remote OK Jobs Feed Scraper (`automation-lab/remoteok-remote-jobs-feed`) Actor

Search, filter, and export current Remote OK jobs with company, role tags, location constraints, salary when shown, dates, source IDs, descriptions, and application URLs.

- **URL**: https://apify.com/automation-lab/remoteok-remote-jobs-feed.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 item extracteds

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?

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

## Remote OK Jobs Feed Scraper

Search, filter, and export current **Remote OK jobs** as structured records for recruiting feeds, labor-market research, and recurring hiring monitoring.

The Actor reads Remote OK's public structured feed and returns normalized company, role, tags, location constraints, compensation when shown, publication date, source ID, description, listing URL, and application URL.

It needs no Remote OK account, browser, cookies, or proxy.

### What does this Actor do?

Remote OK Jobs Feed Scraper turns the current public Remote OK feed into an integration-ready Apify dataset.

You can:

- search across job titles, companies, tags, locations, and descriptions;
- require exact Remote OK role or technology tags;
- filter by displayed candidate location;
- keep only jobs published after a fixed date;
- use a rolling publication window for scheduled runs;
- keep only jobs where salary bounds are shown;
- export plain-text descriptions, with optional source HTML;
- limit output for predictable downstream workflows.

Results are sorted newest first and deduplicated by Remote OK job ID.

### Who is it for?

**Recruiting teams** can create a focused feed of recently posted remote roles.

**Job aggregators** can ingest stable source IDs, canonical listing links, and direct application URLs.

**Hiring-market analysts** can compare role tags, location eligibility, and displayed compensation.

**Data engineers** can schedule runs and send JSON, CSV, or Excel exports to a warehouse or spreadsheet.

**Automation builders** can trigger downstream alerts from newly published matching records.

### Why use this Remote OK jobs scraper?

The Actor uses a lightweight public JSON route rather than rendering pages in a browser.

That gives users:

- a small 256 MB memory footprint;
- no proxy configuration;
- no login or cookie setup;
- typed output suitable for APIs and integrations;
- strict input validation and explicit upstream failures;
- stable source attribution on every row;
- one rolling-day filter designed for recurring feeds.

It is source-specific. Choose a multi-board Actor when you need normalized results from several job boards in one run.

### Data you can extract

| Field | Meaning |
| --- | --- |
| `jobId` | Stable Remote OK source identifier |
| `title` | Displayed role title |
| `company` | Hiring company |
| `companyLogo` | Company logo URL when exposed |
| `tags` | Remote OK role and skill tags |
| `location` | Displayed location or candidate eligibility |
| `isWorldwide` | Whether the location appears open worldwide |
| `salaryMin` | Displayed minimum annual salary in USD |
| `salaryMax` | Displayed maximum annual salary in USD |
| `salaryCurrency` | `USD` when salary data is shown |
| `postedAt` | Publication time in ISO 8601 format |
| `description` | Normalized plain-text job description |
| `descriptionHtml` | Optional source HTML description |
| `applyUrl` | Direct application URL exposed by Remote OK |
| `listingUrl` | Canonical Remote OK listing URL |
| `source` | Normalized source value, `remoteok` |
| `sourceUrl` | Public structured feed URL |
| `scrapedAt` | Extraction timestamp |

Source fields may be `null` when Remote OK does not display them.

### How to scrape Remote OK jobs

1. Open the Actor in Apify Console.
2. Add optional search terms or exact tags.
3. Set a location, publication window, or salary requirement if needed.
4. Choose the maximum number of jobs.
5. Click **Start**.
6. Open the **Dataset** tab to inspect or export results.
7. Download JSON, CSV, Excel, XML, or RSS through Apify dataset tools.

The prefilled input searches for jobs containing `engineer` and returns up to 10 records.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `searchTerms` | string array | `[]` | Every term must occur across searchable job text |
| `tags` | string array | `[]` | Every value must exactly match a Remote OK tag |
| `location` | string | unset | Case-insensitive location or eligibility substring |
| `postedAfter` | ISO date-time | unset | Fixed publication cutoff |
| `postedWithinDays` | integer | unset | Rolling 1–365 day publication window |
| `salaryOnly` | boolean | `false` | Require a displayed salary bound |
| `includeDescriptionHtml` | boolean | `false` | Include source description HTML |
| `maxItems` | integer | `50` | Save between 1 and 500 matching jobs |

Use either `postedAfter` or `postedWithinDays`, not both.

Search terms are combined with AND logic.

Tags are also combined with AND logic.

### Input examples

Search engineering jobs:

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

Export the latest jobs without a search filter:

```json
{
  "maxItems": 20,
  "includeDescriptionHtml": false
}
```

Build a rolling salary feed for scheduled monitoring:

```json
{
  "postedWithinDays": 30,
  "salaryOnly": true,
  "maxItems": 50
}
```

### Output example

A current result has this shape:

```json
{
  "jobId": "123456",
  "title": "Backend Engineer",
  "company": "Example Technology Company",
  "companyLogo": null,
  "tags": ["engineering", "javascript"],
  "location": "Worldwide",
  "isWorldwide": true,
  "salaryMin": 90000,
  "salaryMax": 130000,
  "salaryCurrency": "USD",
  "postedAt": "2026-08-20T12:00:00.000Z",
  "description": "Build reliable backend services for a distributed product team.",
  "applyUrl": "https://remoteok.com/l/123456",
  "listingUrl": "https://remoteok.com/remote-jobs/123456-example-company-backend-engineer",
  "source": "remoteok",
  "sourceUrl": "https://remoteok.com/api",
  "scrapedAt": "2026-08-26T12:00:00.000Z"
}
```

The example company and identifier are anonymized. Actual rows contain current source values.

### How much does it cost to export Remote OK jobs?

The Actor uses pay-per-event pricing.

There is a one-time **Run started** event of **$0.005** for each run and an **Item extracted** event for each job saved to the dataset.

| Apify tier | Price per saved job |
| --- | ---: |
| FREE | $0.000920 |
| BRONZE | $0.000800 |
| SILVER | $0.000624 |
| GOLD | $0.000480 |
| PLATINUM | $0.000320 |
| DIAMOND | $0.000224 |

At BRONZE, 10 saved jobs cost about **$0.013**, including the start event.

At BRONZE, 25 saved jobs cost about **$0.025**.

At BRONZE, 100 saved jobs cost about **$0.085**.

Jobs rejected by filters, malformed source rows, and duplicates are not charged as items.

Apify platform usage is included under pay-per-event pricing where shown by the platform.

### Recurring monitoring workflow

Use `postedWithinDays` for a moving window that stays valid on every scheduled run.

A practical workflow is:

1. create a Task with your search, tag, or salary filters;
2. schedule it daily or weekly;
3. use `jobId` as the downstream deduplication key;
4. compare IDs with your previous export;
5. notify a recruiter only for unseen matching IDs;
6. retain `postedAt` and `scrapedAt` to distinguish source publication from collection time.

The Actor exports current records; it does not maintain cross-run history itself.

### Integration ideas

Send matching jobs to Google Sheets for recruiter review.

Load the dataset into BigQuery, Snowflake, or PostgreSQL for trend analysis.

Use Make or Zapier to create Slack alerts for newly seen IDs.

Feed `company`, `title`, `tags`, and salary bounds into an internal recruiting dashboard.

Publish an attributed job feed while retaining the canonical Remote OK listing URL.

Use Apify webhooks to start a downstream Actor after a successful run.

### Run with the Apify API using cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~remoteok-remote-jobs-feed/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["engineer"],"maxItems":10}'
```

Keep API tokens in environment variables or a secret manager.

### Run with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/remoteok-remote-jobs-feed').call({
  searchTerms: ['engineer'],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/remoteok-remote-jobs-feed').call(
    run_input={'searchTerms': ['engineer'], 'maxItems': 10}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/remoteok-remote-jobs-feed"
```

For **Claude Desktop**, **Cursor**, or **VS Code**, add this MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/remoteok-remote-jobs-feed"
    }
  }
}
```

#### Example prompts for MCP

Ask your MCP client:

- “Use the Remote OK Jobs Feed Scraper MCP tool for engineering jobs and return 10 records.”
- “Export Remote OK jobs from the last 30 days that display salary data.”
- “Summarize companies hiring worldwide from this Remote OK dataset.”

### Reliability and failure behavior

The Actor validates the HTTP status, JSON content type, and response shape.

Network errors, HTTP 429, and temporary server errors receive bounded retries.

Deterministic client errors and unexpected response shapes fail the run rather than returning an incomplete feed.

A successful run can contain zero items when no current record matches all supplied filters.

Broad filters are applied after fetching the current public feed, so `maxItems` limits saved matches rather than source retrieval.

### Tips for better results

Start with one broad search term, then inspect current tags in the output.

Use exact values from `tags` when adding the tag filter.

Use `location` only when Remote OK displays a useful eligibility value.

Use `postedWithinDays` instead of manually updating a fixed date in recurring Tasks.

Enable `includeDescriptionHtml` only when your downstream system needs source formatting.

Keep `maxItems` small while testing automation logic.

### Limitations

The Actor covers the current public Remote OK feed, not historical listings removed from that feed.

Remote OK controls availability, field completeness, ordering, and source freshness.

Salary bounds are returned only when the source exposes them.

A location can describe eligibility rather than an office location.

The Actor does not verify employers, job legitimacy, compensation, or application outcomes.

It does not send alerts, compare runs, or persist monitoring history on its own.

The maximum output is 500 jobs per run.

### Legality and responsible use

Use public job data in accordance with applicable law, Remote OK's API terms, and your contractual obligations.

Retain `listingUrl` or another clear follow link to the original Remote OK listing when republishing source data.

Do not use the output for unlawful discrimination, spam, or automated decisions that require human review.

Avoid storing personal information from job descriptions longer than necessary.

You are responsible for your downstream use and retention policy.

### Troubleshooting

**Why did the run return zero jobs?**

Remove filters one at a time. Search terms and tags use AND logic, and salary or date filters can narrow the current feed substantially.

**Why is salary null?**

Remote OK does not expose compensation for every listing. Set `salaryOnly` to keep only records with a salary bound.

**Why did the run fail with an upstream error?**

Inspect the log for HTTP status or response-shape details. Temporary failures are retried automatically; retry later if the public feed is unavailable.

**Why was my input rejected?**

Check array limits, date format, and the 1–500 `maxItems` range. Do not combine `postedAfter` with `postedWithinDays`.

**Can I use a proxy?**

No proxy input is needed or exposed. The Actor uses the anonymous public structured feed directly.

### Related Automation Lab Actors

- [Remote Jobs Multi-Board Feed](https://apify.com/automation-lab/remote-jobs-multi-board-feed) combines Remote OK and Remotive with cross-source normalization and deduplication.
- [Jobgether Remote Jobs Scraper](https://apify.com/automation-lab/jobgether-remote-jobs-scraper) provides a separate remote-job source for complementary coverage.
- [Company Career Page Jobs Scraper](https://apify.com/automation-lab/company-career-page-jobs-scraper) extracts public listings from supplied employer career pages.

### FAQ

**Does the Actor require a Remote OK account?**

No. It reads the anonymous public structured feed.

**Does it use a browser or residential proxy?**

No. It uses direct HTTP with 256 MB memory.

**Can it search descriptions?**

Yes. `searchTerms` match title, company, tags, location, and normalized description text.

**Can it find Remote OK jobs for freshers?**

You can search for terms such as `junior`, `entry level`, or `graduate` when those words appear in current source records. The Actor does not infer seniority that Remote OK does not state.

**Can I export CSV or Excel?**

Yes. Open the default dataset and select the desired export format.

**Can I monitor only new jobs?**

Use a rolling publication window and deduplicate downstream by `jobId`. Cross-run state is intentionally left to your chosen database or automation.

**Is this an official Remote OK product?**

No. It is an independent Apify Actor that reads Remote OK's public feed and preserves source attribution.

# Actor input Schema

## `searchTerms` (type: `array`):

Words that must all appear in the job title, company, tags, location, or description.

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

Exact Remote OK tags that must all be attached to each job, such as engineering or javascript.

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

Case-insensitive text that must appear in Remote OK's location or candidate-eligibility field.

## `postedAfter` (type: `string`):

Optional ISO 8601 date-time cutoff. Do not combine with Posted within days.

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

Rolling publication window for recurring feeds, from 1 to 365 days. Do not combine with Posted after.

## `salaryOnly` (type: `boolean`):

Keep only records where Remote OK exposes a minimum or maximum salary.

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

Add the source HTML description alongside the normalized plain-text description.

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

Maximum number of matching jobs saved to the dataset.

## Actor input object example

```json
{
  "searchTerms": [
    "engineer"
  ],
  "salaryOnly": false,
  "includeDescriptionHtml": false,
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

All matching jobs saved by this run.

# 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 = {
    "searchTerms": [
        "engineer"
    ],
    "salaryOnly": false,
    "includeDescriptionHtml": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/remoteok-remote-jobs-feed").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 = {
    "searchTerms": ["engineer"],
    "salaryOnly": False,
    "includeDescriptionHtml": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/remoteok-remote-jobs-feed").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 '{
  "searchTerms": [
    "engineer"
  ],
  "salaryOnly": false,
  "includeDescriptionHtml": false,
  "maxItems": 10
}' |
apify call automation-lab/remoteok-remote-jobs-feed --silent --output-dataset

```

## MCP server setup

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

```

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/G927blf9kjMcMc3Si/builds/N0lrc2nL4NBausr4Z/openapi.json