# Remote Jobs Scraper: $0.35 per 1,000 Jobs (`zaiq/remote-jobs-scraper`) Actor

Combine public remote job feeds in one searchable dataset. Filter by keyword, category, location, timezone, salary and date. Get source credits, cleaned descriptions, application links and new-job tracking. $0.35 per 1,000 jobs.

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

## Pricing

from $0.35 / 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 Scraper: one feed, source credits and new-job tracking

![Remote Jobs Scraper: Search, Deduplicate & Track New Jobs](https://api.apify.com/v2/key-value-stores/4VJNANhwKgqPpXtAi/records/hero-remote-jobs-scraper.jpg)

Get remote job listings from **Remote OK, We Work Remotely, Jobicy, Arbeitnow and Arbeitnow UK** in one dataset. Keep the original source links, remove exact cross-board duplicates, and filter by role, category, location, timezone, salary or posting date.

**$0.00035 per delivered job** ($0.35 per 1,000), plus Apify’s $0.00005 start charge. Start with `{ "maxResults": 20, "maxPagesPerSource": 1 }`. The default sources are Remote OK, We Work Remotely and Jobicy; balanced ordering shows the newest matches from each source in turn.

### What you get

| Field | What it holds |
|---|---|
| `verdict` | A one-line reading of the listing: location eligibility, published salary, or information to check. It is not an endorsement of the employer. |
| `title`, `company`, `jobType`, `tags`, `categories` | The role, employer, source-stated employment type and tags. Normalized categories use title and category/tag rules. |
| `url`, `applyUrl`, `sourceUrl` | The original listing and application link supplied by the source. Application links are not followed. |
| `source`, `sourceName`, `sourceCredit`, `sourceListings` | Attribution for every contributing board, including alternate source IDs and links when duplicates merge. |
| `postedAt`, `expiresAt`, `observedAt` | UTC dates where supplied. Expired listings are excluded when the feed gives an expiry date. |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Published numeric salary evidence. Missing currency or period stays unknown. No currency conversion or estimated annual salary. |
| `salaryText`, `salaryEvidence`, `salaryOrigin` | A readable range and whether it came from source fields or explicit salary text. |
| `locationRules`, `locationStatus`, `locationEvidence` | The location label and relevant description lines. “Remote” alone does not mean worldwide. Conflicting conditions are flagged. |
| `timezoneRules`, `timezoneOffsets` | Timezone text and explicit UTC/GMT offsets or ranges when available. Named zones are not converted because daylight saving may change them. |
| `description`, `companyLogoUrl` | Cleaned plain text and the source-provided logo URL. Logos are not downloaded; unavailable values are null. |
| `changeType`, `resultId`, `jobKey`, `sourceKeys` | Current, baseline or newly seen status; stable delivery and source identifiers for integration and restart handling. |
| `SUMMARY` | Per-source coverage, cache hits, skipped malformed records, duplicates, filters, route escalation, bytes, timings and charges. |

### What people use it for

- **A searchable jobs database:** Combine the supported feeds in a common format and keep each listing linked to its original source.
- **New-job alerts:** Run New mode on an Apify schedule and connect the resulting dataset to your own notification workflow. The Actor itself sends no messages.
- **Job-market research:** Compare roles, categories and published compensation without treating missing salary as zero.
- **Candidate discovery tools:** Select source-stated location and salary criteria, then let users review the original listing and any eligibility notes.

### How to use it

1. Run the prefilled input for up to 20 jobs from the three default sources.
2. Open **Remote jobs and notes**. The first column explains the result; download JSON, CSV or Excel when ready.
3. Add Keywords or filters. Use **Search in: All** to search company, tags and the cleaned description as well as the title.
4. For ongoing alerts, select **New**, enter a named **New-job state store**, and reuse that store and alert name on sequential scheduled runs. The first run delivers its baseline.
5. Read SUMMARY when a source is partial, a filter gives no matches, or a spending limit stops delivery.

### Input

| Field | Example | Notes |
|---|---|---|
| Keywords | `["engineer", "designer"]` | Literal, case-insensitive phrases. Any is OR; All is AND. Empty returns current listings. |
| Search in | `title` | Choose `all` to include company, tags and description. |
| Result order | `balanced` | Newest match from each source in turn. `newest` sorts the scanned window globally by date. |
| Categories | `["software", "data"]` | Also design, marketing, sales, support, product, operations, finance, hr, writing or other. |
| Locations | `["Germany", "United Kingdom"]` | OR across requested places. Explicit worldwide jobs also match. Unclear or conflicting rules are excluded unless enabled. |
| UTC offset | `UTC+02:00` | Only explicit UTC/GMT rules match by default; keep unknown timezone rules with the separate switch. |
| Minimum salary | `90000` | Requires a comparable published lower bound, currency and period. The default comparison is USD per year. |
| Posted within days | `7` | Zero disables this filter. A source may expose a shorter rolling window. |
| Employment types | `["full-time", "contract"]` | Matches source-stated types; absent types do not pass this filter. |
| Maximum jobs | `20` | 1–5,000 unique delivered jobs. Free notes do not count. |
| Maximum pages per source | `1` | 1–25. Stops earlier when a source has enough affordable matching jobs. More pages do not extend single-page feeds. |
| New-job state store | `remote-job-alert-state` | Required only in New mode. A store name in your Apify account; never run the same alert concurrently. |
| Feed cache store | `remote-jobs-feeds-v1` | Reuse this name across schedules. Feeds refresh no more than once per hour; continuation pages can extend the same pass. |

### Output

Each result is one row in the run's dataset (download it as JSON, CSV, Excel, XML or HTML, or read it through the API). An example row (values shortened):

```json
{
  "verdict": "Remote listing; Canada, USA; USD 190000–240000 / year.",
  "recordType": "job",
  "title": "Staff Design Engineer",
  "company": "Example Software Team",
  "source": "example-board",
  "sourceName": "Example Job Board",
  "sourceJobId": "example-job-104",
  "sourceUrl": "https://jobs.example/jobs/example-job-104",
  "applyUrl": "https://jobs.example/jobs/example-job-104",
  "postedAt": "2026-10-25T10:46:41Z",
  "salaryMin": 190000.0,
  "salaryMax": 240000.0,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salaryText": "USD 190000–240000 / year",
  "locationRules": "Canada, USA",
  "locationStatus": "restricted",
  "jobType": "full-time",
  "tags": [
    "Web, UI & UX Design"
  ],
  "companyLogoUrl": "https://images.example/company-logo.png",
  "changeType": "current"
}
```

This example comes from a real test run on 25 October 2026. Company and board names, the source ID and all site addresses were replaced; no employer marketing copy is included. Dates, salary amounts, currency, location rules and employment type were retained. SUMMARY in the run’s key-value store describes coverage and what was charged.

### Pricing

- **$0.00035 per unique matching job delivered**, the same price on every Apify plan.
- No charge for source failure notes, invalid input, no-match notes or already-seen jobs in New mode. Failed retries themselves are not charged.
- Apify’s **$0.00005 start charge counts towards the buyer’s Maximum cost per run**. It still applies when no jobs are returned.
- No AI calls, account login or model charges. You do not need a source API key.
- Launch price. It may rise later; Apify emails every user 14 days before any price increase takes effect, and a rise can happen at most once a month.

What typical jobs cost at the list price:

| Job | Cost |
|---|---|
| 1 standard job, including start charge | $0.0004 |
| 20 standard jobs, including start charge | $0.00705 |
| 100 standard jobs, including start charge | $0.03505 |
| 1,000 standard jobs, including start charge | $0.3501 |
| No matching or newly seen jobs | $0 in job events; $0.00005 Apify start charge |

Set Maximum cost per run in Apify. A $0.00075 limit covers two jobs and Apify's $0.00005 start charge. The Actor checks the remaining limit before each paid job; free notes still appear after it.

### Tips

- Use balanced ordering for a small sample across sources; choose newest for a chronological feed.
- Select only the sources relevant to your market. Arbeitnow includes many on-site records; only records explicitly marked remote are retained.
- Keep the same cache store and schedule at most hourly. Jobicy’s public API exposes its recent seven-day publication window; not appearing in that feed does not mean a job closed.
- Keep source credits and original listing links when displaying or exporting results. For Jobicy, application buttons must use its canonical job URL.
- For New mode, reuse the state store and alert name. Changing search filters creates a separate baseline; changing only the result/page cap does not.
- Use a small date window and precise keywords if you need a focused dataset. Salary and timezone filters can legitimately return few results because many listings omit them.

### Use it through the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaiq/remote-jobs-scraper").call(run_input={"keywords": ["engineer"], "maxResults": 20, "maxPagesPerSource": 1, "allowResidential": false})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row)
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('zaiq/remote-jobs-scraper').call({"keywords": ["engineer"], "maxResults": 20, "maxPagesPerSource": 1, "allowResidential": false});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP (one call, results back)**

```bash
curl -X POST 'https://api.apify.com/v2/acts/zaiq~remote-jobs-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"keywords": ["engineer"], "maxResults": 20, "maxPagesPerSource": 1, "allowResidential": false}'
```

### Integrations and schedules

- **Schedules:** run it every hour, day or week from the Apify Console (Schedules) and keep a history of results.
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable:** connect it through Apify's integrations, or send each finished run to a **webhook**.
- **Datasets:** results stay in the run's dataset; export them or read them by API whenever you need them.

### Use it with AI agents (MCP)

Add Apify's MCP server with this Actor already pinned (`https://mcp.apify.com?tools=zaiq/remote-jobs-scraper`) to Claude, ChatGPT, Cursor, VS Code or any MCP client. The agent can find this Actor and run it for you: ask it for "find remote engineering jobs matching these location and salary rules, with original source links". AI agents can also pay for runs directly through Apify's agentic payments.

### Limits

- The Actor covers the five listed public feeds, not every remote board or every vacancy on those sites. Some other feeds restrict redistribution and are excluded.
- Remote OK and We Work Remotely expose single rolling feeds. Jobicy offers cursor pages from its recent seven-day window. Arbeitnow and its UK feed use page links and can contain mostly non-remote jobs.
- Page, result, time or spending limits produce partial coverage in SUMMARY. Malformed records are skipped individually. An empty or cut-short feed can trigger the next route; after the last route it remains an explicitly incomplete answer.
- Location matching uses the published location label and common country/region aliases. It is not a full immigration, language, tax-residency or time-overlap eligibility engine. Read the original description.
- Salary is not invented. Some feeds supply amounts without currency or pay period; those amounts remain visible with a note and do not pass a strict salary filter.
- Deduplication uses source IDs, canonical application URLs, or exact normalized employer/title/location within a seven-day date gap across different sources. Different regions or requisitions may remain separate. No fuzzy title merging.
- New-only state records successfully delivered source IDs, not job closures or changes to old listings. The first run returns a baseline. Up to 100,000 source IDs are retained; eviction is reported and an old job may later appear new.
- Run the same alert and cache namespace sequentially. Concurrent runs can race because key-value stores do not provide a transaction across dataset delivery and state updates.
- Public signed-out access only. Login walls and rate limits are reported. No CAPTCHA solving, account access, browser rendering or application submission.
- Descriptions can be shortened at 100,000 characters with a row note. Responses allow up to 24 MB decoded data; source work stops at 300 seconds or 400 requests, with at most 150 requests per host.

### FAQ

**Does remote mean I can work from any country?**

No. A source may restrict countries, regions or working hours. Unknown and conflicting location rules are flagged. A Worldwide filter requires a clear worldwide label unless you explicitly include unknown locations.

**Why is a salary amount present but its currency missing?**

The source supplied a number without enough currency evidence. A dollar symbol alone could refer to several currencies. The Actor retains the amount without guessing USD.

**Why did New mode return jobs on its first run?**

The first run builds a baseline by delivering the matching jobs it can afford. Later runs return only IDs not previously delivered for those filters. Increase the result limit if you want a larger initial baseline.

**Will a restart charge the same job again?**

Rows use stable result keys. Restarting the same run reads its existing dataset and skips acknowledged deliveries. Alert state is updated only for acknowledged rows and their matched source aliases.

**Does a missing job mean it closed?**

No. A listing can leave a rolling feed, move between pages or fall outside a filter. This Actor does not infer closures.

**Can I get jobs from specific employer career pages?**

Use the separate ATS Jobs Scraper for employer boards. This Actor aggregates the listed public remote-job feeds.

**Why did a source return no jobs?**

Filters may be too narrow, the public window may contain no remote records, or the source may have failed. SUMMARY distinguishes those cases and reports pagination limits.

### Related Actors from Zaiq

- [ats-jobs-scraper](https://apify.com/zaiq/ats-jobs-scraper): public employer vacancies across seven applicant-tracking systems
- [workday-jobs-scraper](https://apify.com/zaiq/workday-jobs-scraper): public employer job listings and descriptions

### Support

Questions, a site that changed, or a field you need? Open an issue on this Actor's **Issues** tab: we answer there, usually within a day.

***

Also found as: remote jobs scraper, remote job aggregator, remote jobs API, work from home jobs dataset, remote job alerts, remote jobs salary filter.

# Actor input Schema

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

Public feeds to combine. Empty uses Remote OK, We Work Remotely and Jobicy. Arbeitnow and Arbeitnow UK are optional and retain only records explicitly marked remote. Feed data is cached for one hour.

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

Optional literal, case-insensitive phrases. Any phrase matches by default; use All for AND. Empty returns the newest jobs in the scanned feeds.

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

Optional shortcut for one keyword or phrase, combined with Keywords.

## `keywordMode` (type: `string`):

Match any requested phrase or require all of them.

## `searchIn` (type: `string`):

Title is more precise; All also searches company, tags and cleaned description.

## `sortBy` (type: `string`):

Balanced takes the newest match from each source in turn. Newest sorts the whole scanned window by date.

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

Optional normalized categories inferred from the title and source categories/tags. Choose one or more; empty keeps all.

## `locations` (type: `array`):

Optional countries, regions or literal place names. Country aliases include US, UK, DE, CA and ZA. Explicit worldwide jobs also match; unknown or conflicting rules are excluded unless enabled below. This is a source-label filter, not a work-authorization decision.

## `includeUnknownLocation` (type: `boolean`):

When a location filter is set, also allow missing or conflicting location evidence. Such rows carry notes and a review verdict.

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

Optional UTC offset, e.g. UTC+02:00. Matches explicit UTC/GMT offsets or ranges in the listing; named zones are retained as text and are not guessed.

## `includeUnknownTimezone` (type: `boolean`):

When filtering timezone, also include jobs whose description has no interpretable UTC/GMT rule.

## `salaryMin` (type: `number`):

Minimum of the published range, in Salary currency and Salary period. Zero disables this filter. Unknown amounts, currencies and periods are excluded when filtering. No currency conversion or hourly-to-annual assumptions.

## `salaryCurrency` (type: `string`):

Three-letter currency code used only for the salary filter.

## `salaryPeriod` (type: `string`):

Compare only salaries with this published pay period.

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

Keep jobs posted in this many days; zero disables the date filter. This cannot recover jobs outside the source feed window.

## `jobTypes` (type: `array`):

Optional source-stated employment types. Unknown types are excluded when filtering.

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

Maximum unique paid jobs delivered in total, including rows already delivered before a restart. Notes do not count. Results follow Result order within the scanned feed window.

## `maxPagesPerSource` (type: `integer`):

Maximum sequential pages to scan from each paginated source (up to 25). Stops sooner once that source has enough matching unseen jobs for the affordable result target. Remote OK and We Work Remotely each publish a single rolling feed. SUMMARY flags unscanned pages; absence never proves closure.

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

Return descriptions as plain text. Turning this off reduces dataset size; descriptions arrive inside the feed so it does not reduce source requests.

## `mode` (type: `string`):

Search returns current matches. New returns only previously undelivered matching source IDs, using the named state store below. The first new-only run delivers its baseline.

## `stateStoreName` (type: `string`):

Required for New mode. Use an Apify key-value store name you own and reuse it on later runs. Run the same alert sequentially; concurrent runs can duplicate alerts.

## `alertKey` (type: `string`):

Separate alerts in the same state store. Filters are included in the state key; changing filters starts a separate baseline.

## `cacheStoreName` (type: `string`):

Reusable named key-value store in your account. Reuse this name across schedules to honor hourly feed refreshes. Do not schedule overlapping refreshes.

## Actor input object example

```json
{
  "sources": [
    "remoteok",
    "weworkremotely",
    "jobicy"
  ],
  "keywords": [],
  "keyword": "",
  "keywordMode": "any",
  "searchIn": "title",
  "sortBy": "balanced",
  "categories": [],
  "locations": [],
  "includeUnknownLocation": false,
  "timezone": "",
  "includeUnknownTimezone": false,
  "salaryMin": 0,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedWithinDays": 0,
  "jobTypes": [],
  "maxResults": 20,
  "maxPagesPerSource": 1,
  "includeDescription": true,
  "mode": "search",
  "stateStoreName": "",
  "alertKey": "default",
  "cacheStoreName": "remote-jobs-feeds-v1"
}
```

# Actor output Schema

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

Dataset: the results.

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

What each input returned, and notes.

# 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 = {
    "sources": [
        "remoteok",
        "weworkremotely",
        "jobicy"
    ],
    "maxResults": 20,
    "maxPagesPerSource": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaiq/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 = {
    "sources": [
        "remoteok",
        "weworkremotely",
        "jobicy",
    ],
    "maxResults": 20,
    "maxPagesPerSource": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("zaiq/remote-jobs-scraper").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 '{
  "sources": [
    "remoteok",
    "weworkremotely",
    "jobicy"
  ],
  "maxResults": 20,
  "maxPagesPerSource": 1
}' |
apify call zaiq/remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/l9rUcGNBMn6vrYdeW/builds/7anrvzg0JeSPAcavN/openapi.json
