# JustRemote Jobs Scraper (`kinaesthetic_millionaire/justremote`) Actor

A fast and reliable web scraper for collecting remote job listings from JustRemote site. Scrape job details as well as company details from the job listings. Now you can skip duplicate job listings across multiple runs using reliable caching system.

- **URL**: https://apify.com/kinaesthetic\_millionaire/justremote.md
- **Developed by:** [Parsedom Inc](https://apify.com/kinaesthetic_millionaire) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 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 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

## JustRemote Remote Job Scraper

A fast and reliable web scraper for collecting remote job listings from [JustRemote](https://justremote.co). Designed for developers, job seekers, recruiters, and HR professionals who need structured remote job data from one of the most comprehensive remote job boards available.

The scraper automatically extracts key listing details such as job title, salary & perks, job description, job type, apply links, and optionally full company information. 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 perks across roles and companies
- Track new listings as they appear on JustRemote

#### Recruitment & Talent Sourcing

- Build structured databases of remote job openings for internal tracking
- Monitor job postings for specific roles or companies
- 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 across active job listings

#### Lead Generation & Outreach

- Generate lists of companies actively hiring remotely
- Enrich records with company descriptions, logos, and active job links
- 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

| Field               | Type             | Required | Description                                                                           |
| ------------------- | ---------------- | -------- | ------------------------------------------------------------------------------------- |
| `inputUrls`         | array of strings | ✅       | One or more JustRemote URLs (listing pages or individual job pages)                   |
| `maxResults`        | integer          | ❌       | Maximum number of job results to scrape. Omit for no limit                            |
| `enableCache`       | boolean          | ❌       | Cache scraped results to skip already-seen listings on re-runs. Defaults to `false`   |
| `scrapeCompanyInfo` | boolean          | ❌       | Also scrape company profile pages for additional company details. Defaults to `false` |

```json
{
    "inputUrls": ["https://justremote.co/remote-customer-service-jobs/"],
    "maxResults": 5,
    "enableCache": false,
    "scrapeCompanyInfo": true
}
````

#### Supported URL Types

The actor accepts two types of URLs:

- **Listing page** – A listing page on JustRemote site. Example: `https://justremote.co/remote-developer-jobs/` or `https://justremote.co/remote-customer-service-jobs/`
- **Detail page** – A specific job's detail page. Example: `https://justremote.co/remote-manager-exec-jobs/senior-business-systems-analyst-finance-kraken`

***

### ⬆️ Output

Scraped results are shown in the **Storage** tab in Apify.

```json
{
    "URL": "https://justremote.co/remote-manager-exec-jobs/senior-business-systems-analyst-finance-kraken",
    "Title": "Senior Business Systems Analyst - Finance",
    "Job Type": ["permanent", "Fully Remote"],
    "Description": "Own the day-to-day administration, configuration, and stability of NetSuite...",
    "Salary and Perks": "Pay range: $72K - $145K\nBonus program\nEquity program\nWellness allowance\nMedical, dental, vision and 401(k)",
    "About us": "Kraken is your bridge to the world of crypto.",
    "Apply Link": "https://jobs.ashbyhq.com/kraken.com/087924a0-e408-4947-af40-37acd073f6a3",
    "companyInfo": {
        "Name": "Kraken",
        "Logo Link": "https://remoteworker-live-superbrnds.s3.eu-west-2.amazonaws.com/uploads/company/logo/268/logo.jpeg",
        "Description": "By joining Kraken, you'll work on the bleeding edge of bitcoin and other digital assets...",
        "Active Job listings": [
            "https://justremote.co/remote-manager-exec-jobs/senior-business-systems-analyst-finance-kraken"
        ]
    }
}
```

#### Output Fields

| Field              | Type   | Description                                                                  |
| ------------------ | ------ | ---------------------------------------------------------------------------- |
| `URL`              | string | Direct URL to the job listing on JustRemote                                  |
| `Title`            | string | Job title as displayed on the listing                                        |
| `Job Type`         | array  | Employment type and remote classification (e.g. `permanent`, `Fully Remote`) |
| `Description`      | string | Full job description text                                                    |
| `Salary and Perks` | string | Salary range and benefits information, if available                          |
| `About us`         | string | Brief company description from the job listing, if available                 |
| `Apply Link`       | string | Direct URL to the external application page                                  |
| `companyInfo`      | object | *(Only when `scrapeCompanyInfo: true`)* Company profile details — see below  |

##### `companyInfo` Fields

| Field                 | Type   | Description                                                    |
| --------------------- | ------ | -------------------------------------------------------------- |
| `Name`                | string | Company name                                                   |
| `Logo Link`           | string | URL to the company logo image                                  |
| `Description`         | string | Full company description from the JustRemote company profile   |
| `Active Job listings` | array  | URLs of all active job listings for this company on JustRemote |

***

### 🏢 Company Info Scraping

When `scrapeCompanyInfo` is set to `true`, the scraper visits each job's associated company profile page and enriches the result with detailed company information, including the company name, logo, full description, and a list of all their currently active remote job listings.

This is useful for:

- **Targeted outreach** – Build profiles of remote-first companies with active hiring
- **Competitive research** – Understand how many and what types of roles a company is filling
- **ATS enrichment** – Feed company context alongside job data into recruitment tools

***

### ⚡ 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 JustRemote
- **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>
- 🤖 Apify expert page: <https://apify.com/partners/find/parsedom-inc>

**Ready to extract JustRemote job data?**
Add your URLs and start scraping 💼🌍

# Actor input Schema

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

JustRemote jobs listing or detail URLs to scrape.

## `scrapeCompanyInfo` (type: `boolean`):

Scrape company information like title, description, active listings etc.

## `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://justremote.co/remote-customer-service-jobs/"
  ],
  "scrapeCompanyInfo": false,
  "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://justremote.co/remote-customer-service-jobs/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kinaesthetic_millionaire/justremote").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://justremote.co/remote-customer-service-jobs/"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("kinaesthetic_millionaire/justremote").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://justremote.co/remote-customer-service-jobs/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call kinaesthetic_millionaire/justremote --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JustRemote Jobs Scraper",
        "description": "A fast and reliable web scraper for collecting remote job listings from JustRemote site. Scrape job details as well as company details from the job listings. Now you can skip duplicate job listings across multiple runs using reliable caching system.",
        "version": "1.0",
        "x-build-id": "qd8XOilyWpqrQzsaA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kinaesthetic_millionaire~justremote/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kinaesthetic_millionaire-justremote",
                "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~justremote/runs": {
            "post": {
                "operationId": "runs-sync-kinaesthetic_millionaire-justremote",
                "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~justremote/run-sync": {
            "post": {
                "operationId": "run-sync-kinaesthetic_millionaire-justremote",
                "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": "JustRemote jobs listing or detail URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeCompanyInfo": {
                        "title": "Scrape company information also?",
                        "type": "boolean",
                        "description": "Scrape company information like title, description, active listings etc.",
                        "default": false
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
