# JustRemote Jobs Search Scraper (`jobsapi/justremote-jobs-search-scraper`) Actor

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

## Pricing

from $2.99 / 1,000 justremote remote job records

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/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

### What does JustRemote Jobs Search Scraper do?

This Actor collects **public remote job listings** from [JustRemote](https://justremote.co/) and enriches each emitted job from its public detail page, producing a structured, API-friendly alternative dataset. It uses ordinary direct HTTPS requests and public page data; it does not log in, use proxies, or attempt to bypass access controls. A complete record is emitted only when its detail identity is verified and more than 20 meaningful source facts can be mapped. Platform `status` (`SUCCEEDED`/`FAILED`) is separate from data `resultStatus` (`COMPLETE`, `LIMITED`, `SKIPPED`, `DEFERRED`, `NO_DATA`, or `FAILED`).

### Why use JustRemote Jobs Search Scraper?

Use the dataset to review remote roles, compare employer and compensation details, or feed public job facts into a recruiting or research workflow. Each record keeps the original listing/detail URLs, structured responsibilities and requirements, salary facts where published, company information, and the public application link. The Actor also provides a run summary, bounded request receipts, and diagnostics separately from job records.

Apify users can schedule runs, inspect run history, download datasets, and connect results through the Apify API and integrations. This Actor supports listing pagination, multiple public source URLs, and simple new-job filtering; it does not provide arbitrary keyword filters, sorting, or proxy rotation.

### What data can it extract?

| Group | Example fields |
|---|---|
| Job identity | `jobId`, `title`, `url`, `category`, `jobType`, `remoteType` |
| Location and timing | `location`, `country`, `countryList`, `locationRestrictions`, `postedAt`, `validThrough`, `timeZone` |
| Role content | `description`, `roleDescription`, `candidateProfile`, `responsibilities`, `experienceRequirements`, `skills`, `benefits`, `offer` |
| Compensation | `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryCurrencySymbol`, `salaryUnit` |
| Employer | `companyName`, `companyDescription`, `companyIndustry`, `companySize`, `companyTagline`, `companyProfileUrl`, `companyWebsite`, `companyLogoUrl` |
| Application and provenance | `applyUrl`, `sourceUrl`, `scrapedAt`, `detailStatus`, `quality` |

Fields are omitted when JustRemote does not publish them. Compensation currency codes are not inferred from a symbol alone. Larger description sections are retained as readable text, with structured arrays for source-published responsibilities, experience requirements, and benefits.

### How to scrape JustRemote

1. Open the Actor's Input tab and choose a public JustRemote listing URL, or keep the default listing.
2. Set the maximum number of jobs and listing pages; details are always fetched for returned records.
3. Start the run, then inspect the Dataset and `OUTPUT_SUMMARY`. Check `RUN_DIAGNOSTICS` if the run reports limitations, no results, or unavailable access.

### How much does it cost?

There is no fixed per-job price stated here. Apify platform compute and storage costs depend on your account plan and run duration. Every candidate needs a public detail request; the Actor may inspect up to `max(20, 5 × maxItems)` candidates (capped at 500) to find enough complete records, in addition to listing requests. More pages, slower responses, and larger HTML increase run time and compute. No automatic retries, browser sessions, or proxy requests are used.

### Input

See the Input tab for the complete configuration. URLs must use HTTPS and the `justremote.co` or `www.justremote.co` host.

| Field | Type and default | Behavior |
|---|---|---|
| `startUrls` | Array of `{ "url": "..." }`; default is `https://justremote.co/remote-jobs` | Listing URLs are paginated; a direct job-detail URL is fetched once. |
| `jobUrls` | String array; `[]` | Optional direct detail URLs processed alongside `startUrls`. |
| `maxItems` | Integer, 1–200; default `20` | Global maximum of emitted jobs across all supplied URLs. |
| `maxPages` | Integer, 1–20; default `1` | Maximum listing pages per listing URL; direct detail URLs are not paginated. |
| `onlyNewJobs` | Boolean; default `false` | When true, omit IDs found in `knownJobIds`. |
| `knownJobIds` | String array; `[]` | IDs from an earlier run. With an empty list, `onlyNewJobs: true` does not exclude any jobs. |
| `requestTimeoutSecs` | Integer, 5–90; default `30` | Per-request timeout. Requests are not retried. |
| `maxResponseBytes` | Integer, 100,000–5,000,000; default `5,000,000` | Responses exceeding this read limit are canceled and deferred. |

Example — quick run:

```json
{
  "maxItems": 5,
  "maxPages": 1
}
```

Example — one category listing plus direct details:

```json
{
  "startUrls": [
    { "url": "https://justremote.co/remote-developer-jobs" }
  ],
  "jobUrls": [
    "https://justremote.co/remote-developer-jobs/senior-software-engineer-control-plane-starburst-data"
  ],
  "maxItems": 10,
  "maxPages": 2,
  "requestTimeoutSecs": 30,
  "maxResponseBytes": 5000000
}
```

Example — skip IDs already seen:

```json
{
  "maxItems": 5,
  "onlyNewJobs": true,
  "knownJobIds": ["27466", "27464"]
}
```

Custom URLs determine what source pages are fetched. `maxItems` is global across listing and detail inputs; `maxPages` applies separately to each listing URL. Start URLs are deduplicated. Because `startUrls` has a default listing, pass `"startUrls": []` when running only the URLs in `jobUrls`. Detail enrichment is mandatory, and the Actor may skip a candidate if its source page cannot be matched to the listing or if the mapped record has 20 or fewer meaningful facts.

### Output

The Dataset contains job records only; diagnostics and request receipts are stored in the Key-value store. Optional source fields are absent when unpublished. Each emitted job has more than 20 meaningful source facts, and `quality.meaningfulFields` explains how that count was reached. The following anonymized example shows the record structure; real records vary by the target page.

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "recordType": "justremote-job",
  "jobId": "example-001",
  "title": "Senior Software Engineer",
  "companyName": "Example Analytics",
  "url": "https://justremote.co/remote-developer-jobs/example-engineer",
  "applyUrl": "https://jobs.example.org/apply/example-engineer",
  "sourceUrl": "https://justremote.co/remote-jobs",
  "jobType": "Permanent",
  "remoteType": "Fully Remote",
  "countryList": ["United States"],
  "validThrough": "2026-12-31T23:59:59.000Z",
  "timeZone": "UTC-5 to UTC-8",
  "overlapRequired": "Four hours of overlap with the North American team",
  "skills": ["Java", "Distributed systems", "Kubernetes"],
  "category": "Developer",
  "postedAt": "2026-09-24T00:00:00.000Z",
  "companyType": "Technology",
  "companyIndustry": "Software",
  "companySize": "201-500 employees",
  "companyTagline": "Analytics for distributed teams",
  "companyDescription": "Example public employer profile.",
  "companyUrl": "https://justremote.co/remote-companies/example-analytics",
  "companyProfileUrl": "https://justremote.co/remote-companies/example-analytics",
  "companyLogoUrl": "https://justremote.co/assets/example-analytics-logo.png",
  "companyWebsite": "https://example.org/",
  "roleDescription": "Build and maintain public data systems.",
  "candidateProfile": "Experience with Java and distributed systems.",
  "offer": "Annual compensation and flexible benefits.",
  "responsibilities": ["Design stable APIs.", "Improve service reliability."],
  "experienceRequirements": ["Experience with Java.", "Experience with distributed systems."],
  "benefits": ["Flexible paid time off.", "Equity package."],
  "salaryText": "$150K - $180K",
  "salaryMin": 150000,
  "salaryMax": 180000,
  "salaryCurrencySymbol": "$",
  "isActive": true,
  "detailFetched": true,
  "detailVerified": true,
  "detailStatus": "success",
  "scrapedAt": "2026-09-25T00:00:00.000Z",
  "recordId": "example-001",
  "recordStatus": "complete",
  "status": "active",
  "accessStatus": "public",
  "dataAvailable": true,
  "found": true,
  "sourceWebsite": "justremote.co",
  "executionEnvironment": "local",
  "dataQuality": "complete",
  "isNew": true,
  "quality": {
    "meaningfulFieldCount": 26,
    "meaningfulFields": [
      "title", "companyName", "jobType", "remoteType", "category", "postedAt", "validThrough",
      "timeZone", "overlapRequired", "companyType", "companyIndustry", "companySize",
      "companyTagline", "companyDescription", "isActive", "countryList[0]",
      "skills[0]", "skills[1]", "skills[2]", "responsibilities[0]", "responsibilities[1]",
      "experienceRequirements[0]", "experienceRequirements[1]", "benefits[0]", "benefits[1]",
      "salary"
    ]
  }
}
```

`OUTPUT` and `OUTPUT_SUMMARY` contain the same run summary. Example successful local summary:

```json
{
  "status": "SUCCEEDED",
  "resultStatus": "COMPLETE",
  "limitedResults": false,
  "sourceUrls": ["https://justremote.co/remote-jobs"],
  "candidateJobs": 3,
  "itemCount": 3,
  "records": 3,
  "newItemCount": 3,
  "skippedKnownCount": 0,
  "diagnosticCount": 0,
  "listingPagesFetched": 1,
  "detailPagesFetched": 3,
  "requests": 4,
  "dataAvailable": true,
  "accessStatus": "public",
  "accessMode": "ordinary_direct_https",
  "proxyUsed": false,
  "fingerprintingUsed": false,
  "retries": 0,
  "localOnly": true,
  "executionEnvironment": "local",
  "requestedUrls": [
    "https://justremote.co/remote-jobs",
    "https://justremote.co/remote-developer-jobs/example-001",
    "https://justremote.co/remote-developer-jobs/example-002",
    "https://justremote.co/remote-developer-jobs/example-003"
  ],
  "finishedAt": "2026-09-25T00:00:00.000Z"
}
```

When the ordinary public request is explicitly denied, the Actor records a diagnostic, stops source requests, discards buffered records, and reports platform `SUCCEEDED` with `resultStatus: SKIPPED` (unless artifact persistence itself fails). This is an illustrative diagnostic, not a claim that the current run was blocked:

```json
{
  "code": "BLOCKED_SOURCE_STATUS",
  "status": 403,
  "url": "https://justremote.co/remote-jobs",
  "message": "JustRemote denied the ordinary public request.",
  "evidence": "HTTP 403 from the requested public page; no retry or alternate route was attempted.",
  "receiptSha256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
  "recordedAt": "2026-09-25T00:00:00.000Z"
}
```

### Tips and advanced options

- Keep `maxPages` small for a quick test. Each candidate detail page adds one request.
- Use `knownJobIds` with `onlyNewJobs` for simple cross-run filtering; this does not persist state between runs automatically.
- Increase `requestTimeoutSecs` only for slow public responses. If `maxResponseBytes` is exceeded, the run is deferred rather than reading an unbounded page.
- A visible CAPTCHA/security challenge or HTTP 401, 403, 429, or 451 ends requests to that source. The Actor does not retry, switch identities, use cookies/proxies, change fingerprints, or solve a challenge. Generic transport or parser failures are reported as deferred or limited, not mislabeled as a site block.

### FAQ, support, and responsible use

If there are fewer jobs than requested, check `OUTPUT_SUMMARY` and `RUN_DIAGNOSTICS`; a source barrier, incomplete detail, or the 20-fact quality gate may explain the difference. `REQUEST_RECEIPTS` records request URL, status, byte count, response hash, elapsed time, purpose, and whether the response hit the size cap; receipts never store response bodies. The Actor does not send authentication headers or cookies. Local storage is not uploaded to Apify Console automatically.

For an issue, include the run ID and relevant summary from the Actor's Issues tab. Use the API tab for dataset and key-value access. The Actor is not affiliated with JustRemote. Use only publicly available information, follow JustRemote's terms, robots guidance, and applicable rate limits, and comply with privacy and data-protection laws. Public job records can still contain personal data; use them only for a lawful, legitimate purpose and seek qualified legal advice when unsure.

# Actor input Schema

## `startUrls` (type: `array`):

Public JustRemote listing pages such as /remote-jobs or individual job detail pages. Each supplied URL is requested once.

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

Optional public detail URLs to process in addition to listing URLs.

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

Maximum number of unique jobs written to the dataset.

## `maxPages` (type: `integer`):

Maximum listing pages requested for each supplied listing URL. Direct detail URLs are not paginated.

## `onlyNewJobs` (type: `boolean`):

Omit IDs included in knownJobIds after checking listing facts. Every emitted job still receives mandatory detail enrichment.

## `knownJobIds` (type: `array`):

Job IDs from a prior run for simple change monitoring.

## `requestTimeoutSecs` (type: `integer`):

Maximum duration for each ordinary direct public request. Requests are not automatically retried.

## `maxResponseBytes` (type: `integer`):

Maximum response bytes read; larger responses are canceled and deferred.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://justremote.co/remote-jobs"
    }
  ],
  "jobUrls": [],
  "maxItems": 20,
  "maxPages": 1,
  "onlyNewJobs": false,
  "knownJobIds": [],
  "requestTimeoutSecs": 30,
  "maxResponseBytes": 5000000
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `datasetUi` (type: `string`):

No description

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

No description

## `diagnostics` (type: `string`):

No description

## `receipts` (type: `string`):

No description

## `health` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/justremote-jobs-search-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/justremote-jobs-search-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 '{}' |
apify call jobsapi/justremote-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jobsapi/justremote-jobs-search-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/BZdeNyzbMQoAShy11/builds/kEo37S77Rd6d6fD26/openapi.json
