# Working Nomads Remote Jobs Scraper – Live Data (`b2b_leads/working-nomads-real-time-data-scraper`) Actor

Collect live remote-job listings from Working Nomads in real time. Search by keyword, category, and location, enrich rows with direct apply links, or refresh pasted job URLs. Structured JSON streams to your dataset with webhooks, pay-per-event, and a 2-result free trial.

- **URL**: https://apify.com/b2b_leads/working-nomads-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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/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

## Working Nomads Real-Time Data

Live remote-job listings from Working Nomads, delivered as structured JSON the second you run it. Search by keyword, category, and location, enrich rows with direct apply links, or refresh job URLs you already have — every record streams to your dataset in real time, with optional webhooks for CRMs, Slack, and automation tools.

> **Free-plan notice:** runs on the Apify free plan receive a 2-result sample per run. Upgrade to a paid Apify plan for full, unlimited data.

### Who it's for

- **Recruiters & sourcing teams** building live pipelines of remote openings by role, skill, or category
- **Job-board operators & aggregators** keeping remote listings fresh without manual copying
- **Career platforms & newsletters** curating remote roles for niche audiences
- **Market researchers** tracking remote-hiring trends across categories and regions
- **Automation builders & AI agents** feeding structured job data into matchers, alerts, and CRMs

### Use cases

1. **Live role sourcing** — pull every new Development, Marketing, or Support opening with company, tags, and apply link.
2. **Skill-based alerts** — search keywords like "python", " HubSpot", or "video editing" and push matches to Slack via webhook.
3. **Listing refresh** — paste job URLs you already store and re-collect them as clean structured rows.
4. **Salary & market research** — export full descriptions across categories for analysis (all listings are remote).
5. **CRM enrichment** — stream new openings straight into your ATS, sheet, or pipeline tool on every run.
6. **Niche curation** — filter by location wording (e.g. "Europe", "Global") to build region-specific feeds.

### Features

| Feature | What you get |
|---|---|
| 💼 Job search (default on) | Keyword + category + location search over the live feed: title, company, category, tags, locations, full description, posting date |
| 🎯 Job details (enrich in place) | Adds each job's direct apply link to the same row. Rows without a resolvable link are still exported — nothing is dropped |
| 🔗 Scrape by URL | Paste Working Nomads job URLs and collect them as structured rows, even if they left the live feed |
| 🔔 Webhooks (JSON + Slack) | Every row is saved to the dataset and optionally pushed to your URL in real time |
| 💰 Pay-per-event ready | One `result` charge per exported row; spending-limit stops are graceful, never errors |
| 🆓 Free-tier gating | Transparent 2-result sample for free plans, full output for paying users |

### Input reference

| Field | Type | Default | Example |
|---|---|---|---|
| `enableJobSearch` | checkbox | `true` | — |
| `jobKeywords` | string list | `["software engineer"]` | `["customer support", "python"]` — empty = browse everything |
| `jobCategories` | string list | `[]` (all) | `["Development", "Marketing", "Design"]` |
| `jobLocation` | text | `""` (all) | `"Europe"`, `"United States"`, `"Global"` |
| `jobsMaxResults` | number | `10` | Max jobs **per keyword** (`50`; `0` = no cap) — each keyword gets its own capped pass |
| `enableJobDetails` | checkbox | `false` | Adds apply links in place; adds a little extra time per record |
| `enableScrapeByUrl` | checkbox | `false` | — |
| `jobUrls` | string list | `[]` | `["https://www.workingnomads.com/job/go/1939844/"]` |
| `webhookUrl` | text | `""` | `https://hooks.slack.com/...` or any HTTPS URL |
| `webhookFormat` | select | `"json"` | `"json"` (full record) or `"slack"` (message) |
| `proxyConfiguration` | proxy | Residential US | Change only for a different country or custom proxies |

Available categories: Administration, Consulting, Customer Success, Design, Development, Education, Finance, Healthcare, Human Resources, Legal, Management, Marketing, Sales, System Administration, Writing.

**First run in seconds:** leave the defaults and click Start — you'll get live software-engineer openings immediately.

### Output reference

One row per job, streamed to the dataset as it is finalized:

| Field | Example |
|---|---|
| `featureType` | `"job_search"`, `"job_details"`, `"scrape_by_url"` |
| `recordType` | `"job"` |
| `jobId` | `"1939844"` |
| `title` | `"Senior Full-stack PHP Developer"` |
| `companyName` | `"Lemon.io"` |
| `category` | `"Development"` |
| `tags` | `["php", "react", "laravel"]` |
| `location` | `"Europe, LATAM, APAC, the U.S., Canada"` |
| `remote` | `true` |
| `jobUrl` | `"https://www.workingnomads.com/job/go/1939844/"` |
| `applyUrl` | Direct application link (when details enabled) |
| `description` | Full plain-text description |
| `postedAt` | `"2026-10-13T10:06:11.000Z"` |
| `detailsFetched` | `true` when the details pass ran on this row |
| `searchQuery` | Keywords recorded as context |
| `source` | `"live_feed"` or `"job_link"` |
| `scrapedAt` | Collection timestamp |

The run summary (counts, enabled features, paywall transparency, spending-limit status) is stored under `OUTPUT` in the key-value store.

### Webhooks

Set `webhookUrl` to receive each record as an additional real-time POST alongside the dataset write:

- **`json`** — the full job record object. Point it at Zapier, Make, your CRM, or a custom URL.
- **`slack`** — a compact message (title, company, category, location, tags, apply link) for Slack incoming webhooks.

Delivery is fire-and-forget: a failing webhook never stops the run or the dataset write.

### MCP / AI-agent usage

Pair this Actor with the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so assistants can call it directly. Example prompts:

- *"Find live remote customer-support jobs on Working Nomads and send the top 5 to my webhook."*
- *"Get full details with apply links for these Working Nomads job URLs and summarize the best fit for a Python developer."*
- *"Which remote development jobs were posted this week? Group them by company."*

### FAQ

**Do I need my own proxies?**
No. The Actor runs on Apify residential proxies (US) by default. Override the proxy settings only if you need a different country or your own proxy URLs.

**What does the free trial include?**
Free-plan runs get a 2-result sample with a clear upgrade note. Everything else — fields, webhooks, features — works exactly the same.

**How fresh is the data?**
Every run collects the current live feed, so results reflect what's listed right now. Re-run on a schedule for change tracking.

**Why is a row missing its apply link?**
Some listings don't advertise a separate destination. The row is still exported with everything else — enrichment only adds, never removes.

**How am I charged?**
The Actor charges one `result` event per exported row. `jobsMaxResults` is your cost lever; spending-limit stops finish gracefully with data kept.

# Actor input Schema

## `enableJobSearch` (type: `boolean`):

Search live Working Nomads remote-job listings by keyword, category, and location. On by default.

## `jobKeywords` (type: `array`):

Search terms matched against job title, company, description, and tags (e.g. "software engineer", "customer support"). Leave empty to browse the whole live feed.

## `jobCategories` (type: `array`):

Narrow results to job families: Administration, Consulting, Customer Success, Design, Development, Education, Finance, Healthcare, Human Resources, Legal, Management, Marketing, Sales, System Administration, Writing. Leave empty for all categories.

## `jobLocation` (type: `string`):

Optional location filter matched against each job's listed locations (e.g. "United States", "Europe", "Global"). Leave empty for all locations.

## `jobsMaxResults` (type: `integer`):

Cap the number of job rows collected per keyword. Each keyword gets its own capped pass, so two keywords can yield up to twice this cap. With no keywords, it caps the single browse pass. This is the main cost lever. 0 = no cap.

## `enableJobDetails` (type: `boolean`):

Enrich each job row in place with its direct apply link (resolved per job). Every job is still exported even when no apply link is found (nothing is dropped). Adds a little extra time per record. Off by default for the fastest runs.

## `enableScrapeByUrl` (type: `boolean`):

Collect structured job rows from individual Working Nomads job URLs you paste below. Off by default — turn on and add job URLs.

## `jobUrls` (type: `array`):

Working Nomads job page URLs to collect (only used when Scrape by URL is enabled).

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also delivered to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

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

Apify residential proxy (US) is enabled by default for reliable collection. Change here only if you need a different country or custom proxy URLs.

## Actor input object example

```json
{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer",
    "data analyst"
  ],
  "jobCategories": [],
  "jobLocation": "",
  "jobsMaxResults": 10,
  "enableJobDetails": false,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every field from all enabled features in this run.

## `jobs` (type: `string`):

Remote-job rows from the live Working Nomads feed.

## `runSummary` (type: `string`):

Per-run metadata: enabled features, exported record count, non-fatal errors, spending-limit status, and the paywall object (detected, isPaying, pricingTier, blocked, limited).

# 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 = {
    "enableJobSearch": true,
    "jobKeywords": [
        "software engineer",
        "data analyst"
    ],
    "jobCategories": [],
    "jobLocation": "",
    "jobsMaxResults": 10,
    "enableJobDetails": false,
    "enableScrapeByUrl": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/working-nomads-real-time-data-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 = {
    "enableJobSearch": True,
    "jobKeywords": [
        "software engineer",
        "data analyst",
    ],
    "jobCategories": [],
    "jobLocation": "",
    "jobsMaxResults": 10,
    "enableJobDetails": False,
    "enableScrapeByUrl": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/working-nomads-real-time-data-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 '{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer",
    "data analyst"
  ],
  "jobCategories": [],
  "jobLocation": "",
  "jobsMaxResults": 10,
  "enableJobDetails": false,
  "enableScrapeByUrl": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/working-nomads-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/working-nomads-real-time-data-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/1KXL0SByibn9Dqq0e/builds/99GfnMXOwSmgpIur9/openapi.json