# RemoteOK Scraper (`parseforge/specialized-job-boards-scraper`) Actor

Extract remote tech jobs from RemoteOK — title, company, salary, skills, apply URL, location, and posting date. Free preview caps at 10 jobs. Great for job seekers, recruiters, and market analysts building custom remote work feeds without coding.

- **URL**: https://apify.com/parseforge/specialized-job-boards-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Social media
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💼 RemoteOK Jobs Scraper

Collect remote job listings from RemoteOK.com without coding. This scraper extracts job title, company, salary, required skills, category, job type, and posting date, making it perfect for job seekers building custom remote job feeds, recruiters monitoring remote talent pools, or data analysts researching the remote work market.

> **The RemoteOK Jobs Scraper collects remote job listings with up to 18 data fields per job, including salary parsing, skills extraction, and job categorization.**

### ✨ What Does It Do

- 📝 **Job Title** - Track exact job positions to identify hiring trends for specific roles
- 💼 **Company Name** - See which companies are actively hiring for your target skills
- 🌍 **Location** - Filter opportunities by city, region, or remote status
- 💰 **Salary Range** - Collect minimum and maximum salary data with currency for compensation analysis
- 🛠️ **Required Skills** - Identify technical skills in demand across current openings
- 📋 **Full Description** - Read complete job posting text for deeper market research
- 📅 **Posting Date** - Track freshness of listings and hiring cycles
- 🎯 **Employment Type** - Distinguish full-time, part-time, and contract opportunities

### 🔧 Input

- **Search Keyword** - What job title or skill to search for (e.g. python, javascript, devops). Leave empty for all remote jobs.
- **Max Items** - How many job listings to collect per run

Example input:
```json
{
  "keyword": "python",
  "maxItems": 10
}
````

### 📊 Output

Each job listing includes up to 25 data fields. Download as JSON, CSV, or Excel.

| 📝 Job Title | 💼 Company Name | 🌍 Location |
|---|---|---|
| 💰 Salary (text) | 📊 Salary Min | 📊 Salary Max |
| 💱 Salary Currency | 🛠️ Required Skills | 📋 Job Description |
| 📅 Date Posted | 📌 Location Type | 👔 Employment Type |
| 🔗 Job URL | 🔗 Apply URL | 🆔 Job ID |
| 🏢 Company Logo | 🌐 Company URL | 📍 Source Board |
| ⏰ Scraped At | ⚠️ Error (if any) | |

### 💎 Why Choose the RemoteOK Jobs Scraper?

| Feature | Our Actor |
|---|---|
| Fast API-based extraction (no browser needed) | ✔️ |
| Salary parsing (min, max, currency extraction) | ✔️ |
| Skills and category extraction | ✔️ |
| Job type classification | ✔️ |
| Company logos and apply URLs | ✔️ |
| CSV, Excel, and JSON export | ✔️ |
| Automatic retry logic with exponential backoff | ✔️ |
| Support for large-scale collection (1 million+ items) | ✔️ |
| Track posting date and scrape timestamp | ✔️ |

### 📋 How to Use

No technical skills required. Follow these simple steps:

1. **Sign Up** - [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool** - Search for "RemoteOK Jobs Scraper" in the Apify Store and enter your search keyword
3. **Run It** - Click "Start" and watch your results appear

That's it. No coding, no setup needed. Export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Data Analyst** - Monitor salary trends across remote jobs for 100+ tech roles monthly to publish quarterly compensation benchmarks
- 💼 **Technical Recruiter** - Collect active developer listings daily to identify passive candidates before competitors reach them
- 🔬 **Market Researcher** - Track remote job growth week-over-week to measure the work-from-home shift

### ❓ FAQ

**🔍 How does this scraper work?**
The scraper connects to RemoteOK's public API and extracts job fields into structured records. No browser or HTML parsing needed - pure API access for fast and reliable results.

**📊 How accurate is the salary data?**
Salary data comes directly from the job postings. We parse ranges (e.g. "$80k - $120k") into minimum and maximum fields and detect currency symbols. If a posting says "Depends on experience" or is blank, we skip the salary field. Accuracy depends on how consistently each board formats salary information.

**📅 Can I schedule this to run automatically?**
Yes. Use the Apify scheduler to run this actor on a daily, weekly, or monthly basis. You can also integrate it with Make, Zapier, or GitHub Actions for automated job feed updates.

**⚖️ Is scraping RemoteOK allowed?**
RemoteOK is a public job board with a public API. You are collecting publicly visible data. Always review the site terms of service and ensure your use case complies with local laws and regulations.

**🛡️ Will RemoteOK block me?**
RemoteOK has a public API that is accessed directly, so requests are unlikely to be blocked. No proxies needed.

**⚡ How long does a run take?**
A run collecting 10 jobs takes a few seconds. RemoteOK's API returns all results in a single request.

**⚠️ Are there any limits?**
Free users get up to 10 items. Paid users can collect up to 1,000,000 results.

### 🔗 Integrate RemoteOK Jobs Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

- [Stack Overflow Jobs Scraper](https://apify.com/parseforge/stack-overflow-jobs-scraper) - Collect programming job listings with detailed requirements and skill filters
- [UPS Package Tracking Scraper](https://apify.com/parseforge/ups-package-tracking-scraper) - Monitor package delivery status and tracking updates
- [Bonanza Marketplace Scraper](https://apify.com/parseforge/bonanza-scraper) - Extract seller listings and marketplace data
- [PharmacyChecker Scraper](https://apify.com/parseforge/pharmacychecker-scraper) - Find medication costs and pharmacy locations
- [Cemetery Records Scraper](https://apify.com/parseforge/cemetery-records-scraper) - Search and extract cemetery burial records

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 100 results for free. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by RemoteOK.com or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `keyword` (type: `string`):

Job search keyword (e.g. python, javascript, react, devops).

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Proxy settings for the scraper. Use Apify proxies or your own.

## Actor input object example

```json
{
  "keyword": "python",
  "maxItems": 10
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "keyword": "python",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/specialized-job-boards-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 = {
    "keyword": "python",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/specialized-job-boards-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 '{
  "keyword": "python",
  "maxItems": 10
}' |
apify call parseforge/specialized-job-boards-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RemoteOK Scraper",
        "description": "Extract remote tech jobs from RemoteOK — title, company, salary, skills, apply URL, location, and posting date. Free preview caps at 10 jobs. Great for job seekers, recruiters, and market analysts building custom remote work feeds without coding.",
        "version": "1.0",
        "x-build-id": "qYVyjsZOUmOVK11hf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~specialized-job-boards-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-specialized-job-boards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~specialized-job-boards-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-specialized-job-boards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~specialized-job-boards-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-specialized-job-boards-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Job search keyword (e.g. python, javascript, react, devops)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Use Apify proxies or your own."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
