# NoDesk Remote Jobs Scraper (`kinaesthetic_millionaire/nodesk-remote-jobs-scraper`) Actor

Nodesk remote jobs scraper actor can scrape remote job listing data from nodesk.com website. It scrapes the job title, salary, jobDescription, apply links and other details. You can use this actor as an API and can connect with any automation systems and also skip duplicate job listings across runs.

- **URL**: https://apify.com/kinaesthetic\_millionaire/nodesk-remote-jobs-scraper.md
- **Developed by:** [Parsedom Inc](https://apify.com/kinaesthetic_millionaire) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Nodesk Remote Job Scraper

A fast and reliable web scraper for collecting remote job listings from [Nodesk](https://nodesk.co). This tool is designed for developers, job seekers, recruiters, and HR professionals who want structured remote job data from one of the most curated remote work job boards available.

The scraper automatically extracts key listing details such as job title, salary, tags, description, locations, job type, field, and direct apply links. It supports multiple URL types — filtered job search pages and individual job detail pages — making it flexible for both broad data collection and targeted job monitoring.

### 🎯 Use Cases

#### Job Search & Career Research

- Browse and filter remote job listings across multiple fields and job types
- Compare salaries and requirements across roles and companies
- Track new listings as they appear on Nodesk

#### Recruitment & Talent Sourcing

- Build structured databases of remote job openings for internal tracking
- Monitor job postings for specific roles or skill tags
- Feed consistent JSON job data into ATS or recruitment pipelines

#### HR & Workforce Analytics

- Analyze remote job market trends by field, location, and job type
- Compare salary ranges across remote roles and industries
- Identify in-demand skills and tags across active job listings

#### Lead Generation & Outreach

- Generate lists of companies actively hiring remotely
- Identify opportunities in specific fields for targeted candidate outreach
- Populate CRM systems with fresh job market insights

#### Automation & Workflow Integration

- Automate recurring data pulls for continuous job monitoring
- Trigger downstream workflows (alerts, digests, reports) based on new listings
- Integrate with business tools (Slack alerts, dashboards, BI platforms)

#### Market Research & Competitive Intelligence

- Monitor which companies are hiring remotely and for what roles
- Analyze job description content for trends in required skills
- Benchmark salary data across remote-first organizations

### ⬇️ Input

`inputUrls` (array of string) – One or more Nodesk URLs. Supports job listing/search pages and individual job detail pages.

`maxResults` (integer) – Maximum number of job results to scrape.

`enableCache` (boolean) – Whether to cache scraped results to avoid re-processing already-seen listings on subsequent runs. Defaults to `false`.

```json
{
    "inputUrls": ["https://nodesk.co/remote-jobs/?query=developer"],
    "maxResults": 10,
    "enableCache": false
}
````

#### Supported URL Types

The actor accepts two types of URLs:

- **Listing / search page** – A filtered or unfiltered listing of remote jobs on Nodesk. Example: `https://nodesk.co/remote-jobs` or `https://nodesk.co/remote-jobs/?query=developer`
- **Detail page** – A specific job's detail page. Example: `https://nodesk.co/remote-jobs/canonical-junior-software-developer-observability/`

### ⬆️ Output

The scraped results will be shown on the **Storage** tab in Apify.

```json
[
    {
        "URL": "https://nodesk.co/remote-jobs/caribbean-and-cruise-experience-wfh-travel-planner/",
        "Title": "WFH Travel Planner",
        "Salary": "$35K – $65K",
        "Tags": ["Non-Tech"],
        "Description": "We are seeking a detail-oriented and customer-focused WFH Travel Planner to join our team. In this role, you will assist clients in planning vacations, getaways, and special trips by researching destinations, preparing travel options, and organizing complete itineraries. You will work closely with clients to understand their preferences and ensure every travel experience is thoughtfully planned, accurate, and stress-free. This position is ideal for someone who enjoys organization, communication, and helping others create memorable travel experiences.Key Responsibilities:Research travel options including flights, hotels, resorts, cruises, and activities based on client needsPrepare and organize quotes, proposals, and detailed travel itinerariesCommunicate with clients to gather information and respond to general inquiriesCoordinate with travel partners and suppliers to confirm bookings and special requestsMaintain accurate client records and travel documentationProvide professional and timely service to ensure high levels of client satisfactionRequirements:Strong communication and interpersonal skillsExcellent organizational skills and attention to detailProficiency with basic computer skills (email, web browsing, Microsoft Office or Google Workspace)Ability to manage multiple tasks, prioritize effectively, and meet deadlinesReliable internet connection and a distraction-free remote workspacePrevious customer service, hospitality, or administrative experience is a plus but not requiredBenefits:Flexible remote work scheduleSupportive and collaborative team environmentOpportunity to build experience in the travel and hospitality industryAccess to travel-related discounts and perks after eligibility requirements are metA rewarding role helping clients plan meaningful and enjoyable travel experiences",
        "Locations": ["North America", "UK", "US"],
        "Job Type": ["Freelance", "Full-Time", "Part-Time"],
        "Field": "Sales",
        "Apply link": "https://form.jotform.com/vacationandcareers/join-our-travel-team"
    }
]
```

#### Output Fields

| Field         | Type   | Description                                                 |
| ------------- | ------ | ----------------------------------------------------------- |
| `URL`         | string | Direct URL to the job listing on Nodesk                     |
| `Title`       | string | Job title as displayed on the listing                       |
| `Salary`      | string | Salary range or compensation info, if available             |
| `Tags`        | array  | Skill tags and keywords associated with the job             |
| `Description` | string | Full job description text                                   |
| `Locations`   | array  | Eligible locations or regions for the role                  |
| `Job Type`    | array  | Employment type (e.g. Full-time, Contract, Part-time)       |
| `Field`       | string | Job category or field (e.g. Engineering, Design, Marketing) |
| `Apply link`  | string | Direct URL to the external application page                 |

### ⚡ Caching

When `enableCache` is set to `true`, the scraper stores previously scraped job listings so that repeat runs skip already-processed URLs. This is useful for:

- **Incremental scraping** – Only pull new listings on each run
- **Reducing load** – Avoid redundant requests to Nodesk
- **Faster subsequent runs** – Previously cached results are returned instantly without re-fetching

Cached results are stored per job URL and are reused automatically on subsequent runs when caching is enabled.

### 🤝 Support

Need help or a custom scraper?

- 📧 <info@parsedom.com>
- 🌐 <https://parsedom.com>
- 💼 Fiverr: <https://www.fiverr.com/s/rEmNqEb>

**Ready to extract Nodesk remote job data?**\
Add your URLs and start scraping 💼🌍

# Actor input Schema

## `inputUrls` (type: `array`):

Nodesk remote jobs listing URLs to scrape.

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

Maximum number of job listings to scrape.

## `enableCache` (type: `boolean`):

Skip already-scraped job URLs from previous runs. Uses a persistent Key-Value Store to remember scraped jobs by URL.

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

Proxy settings for the scraper.

## Actor input object example

```json
{
  "inputUrls": [
    "https://nodesk.co/remote-jobs/?query=Developer"
  ],
  "maxResults": 5,
  "enableCache": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "inputUrls": [
        "https://nodesk.co/remote-jobs/?query=Developer"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kinaesthetic_millionaire/nodesk-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 = {
    "inputUrls": ["https://nodesk.co/remote-jobs/?query=Developer"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("kinaesthetic_millionaire/nodesk-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 '{
  "inputUrls": [
    "https://nodesk.co/remote-jobs/?query=Developer"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call kinaesthetic_millionaire/nodesk-remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NoDesk Remote Jobs Scraper",
        "description": "Nodesk remote jobs scraper actor can scrape remote job listing data from nodesk.com website. It scrapes the job title, salary, jobDescription, apply links and other details. You can use this actor as an API and can connect with any automation systems and also skip duplicate job listings across runs.",
        "version": "1.0",
        "x-build-id": "h3Qh1hCxCaPtSInew"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kinaesthetic_millionaire~nodesk-remote-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kinaesthetic_millionaire-nodesk-remote-jobs-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/kinaesthetic_millionaire~nodesk-remote-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kinaesthetic_millionaire-nodesk-remote-jobs-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/kinaesthetic_millionaire~nodesk-remote-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kinaesthetic_millionaire-nodesk-remote-jobs-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",
                "required": [
                    "inputUrls"
                ],
                "properties": {
                    "inputUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Nodesk remote jobs listing URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape.",
                        "default": 5
                    },
                    "enableCache": {
                        "title": "Enable Cache",
                        "type": "boolean",
                        "description": "Skip already-scraped job URLs from previous runs. Uses a persistent Key-Value Store to remember scraped jobs by URL.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
