# Remote.com Jobs Scraper (`fetch_cat/remote-dot-com-jobs-scraper`) Actor

Scrape public Remote.com job listings, compensation, seniority, departments, locations, and apply links.

- **URL**: https://apify.com/fetch\_cat/remote-dot-com-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 97.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 job results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Remote.com Jobs Scraper

Collect public Remote.com job listings with company names, departments, locations, seniority, compensation ranges, visa sponsorship flags, quick-apply indicators, and apply links.

Remote.com Jobs Scraper is built for recruiters, job-board operators, HR analysts, and remote-work newsletters that need structured job data from Remote.com without manual copy and paste.

### At a glance

- **Input:** Remote.com job listing URLs plus optional keyword, department, location, seniority, limit, and description mode.
- **Output:** One dataset row per public Remote.com job, including title, company, location, compensation, apply URL, quick-apply flag, and visa sponsorship signal when available.
- **Best for:** Remote job-board feeds, hiring intelligence, recruiting alerts, compensation research, and newsletter curation.
- **Pricing unit:** A start event per run plus one `item` event for each saved job record.
- **Login required:** No. The Actor reads public Remote.com job listings only.

### Ready-to-run examples

- [Remote engineering jobs](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper/examples/remote-engineering-jobs) - collect a focused Remote.com engineering feed.
- [Remote customer support jobs](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper/examples/remote-customer-support-jobs) - find support roles for remote-work newsletters or recruiting alerts.
- [Remote data analyst jobs](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper/examples/remote-data-analyst-jobs) - export analyst openings with locations and apply URLs.
- [Remote visa sponsorship jobs](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper/examples/remote-visa-sponsorship-jobs) - monitor roles that mention sponsorship availability.
- [Remote jobs with descriptions](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper/examples/remote-jobs-with-descriptions) - include best-effort job description snippets for richer rows.

### What can it do?

Remote.com Jobs Scraper extracts structured records from public Remote.com job listings.

It can collect:

- **Job and company details:** Title, company name, company website, logo URL, department, location, and source URL.
- **Remote-work filters:** Remote type, seniority, employment type, travel frequency, and location text.
- **Compensation data:** Minimum and maximum compensation, currency, currency symbol, and pay frequency when Remote.com exposes them.
- **Application signals:** Deadline, visa sponsorship availability, quick-apply status, job URL, and apply URL.
- **Freshness fields:** Posted and updated timestamps plus source information for repeatable monitoring.

### Common workflows

- **Recruiting alerts:** Track new Remote.com openings by department, country, seniority, or keyword.
- **Job-board enrichment:** Feed public remote roles into a niche job board, newsletter, or alerting workflow.
- **Compensation research:** Compare salary ranges by location, seniority, department, and currency when compensation is available.
- **Talent intelligence:** Watch which companies are expanding internationally and what functions they are hiring for.
- **API automation:** Schedule runs and export CSV, Excel, JSON, or API results into dashboards and data warehouses.

### Why use this Remote.com job scraper?

Remote.com publishes useful public job-board data, but manually reviewing listings is slow.

This actor turns that public information into a clean dataset that can be exported, filtered, integrated, or scheduled.

Use it when you need repeatable structured data rather than one-off browsing.

### Output fields

| Field | Description |
| --- | --- |
| `title` | Job title |
| `company` | Hiring company name |
| `companyWebsite` | Company website when available |
| `companyLogoUrl` | Company logo URL when available |
| `department` | Department or function |
| `location` | Hiring location or country list |
| `remoteType` | Remote/workplace type |
| `seniority` | Seniority labels |
| `employmentType` | Employment type |
| `travelFrequency` | Travel requirement |
| `deadline` | Application deadline |
| `compensationMin` | Minimum compensation |
| `compensationMax` | Maximum compensation |
| `compensationFrequency` | Pay frequency, such as yearly |
| `currency` | Compensation currency code |
| `currencySymbol` | Currency symbol |
| `visaSponsorshipOffered` | Whether visa sponsorship is offered |
| `quickApply` | Whether quick apply is available |
| `jobUrl` | Remote.com job page |
| `applyUrl` | Apply URL when available |
| `description` | Optional description snippet |
| `postedAt` | Posted date |
| `updatedAt` | Last updated date |
| `source` | Data source name |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost (init, first HTTP setup). | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per Remote.com job result saved to the dataset. | $0.08873 / 1,000 | $0.07716 / 1,000 | $0.06018 / 1,000 | $0.0463 / 1,000 | $0.03086 / 1,000 | $0.0216 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to scrape Remote.com jobs

1. Open the actor on Apify.
2. Keep the default start URL or add another Remote.com jobs URL.
3. Add optional filters such as keyword, department, location, or seniority.
4. Set the maximum number of jobs.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Start URLs | `startUrls` | Remote.com listing pages. Keep the default all-jobs URL or add another public listing URL. | `[{"url":"https://remote.com/jobs/all"}]` |
| Keyword search | `query` | Match text across job title, company, department, seniority, and location. | `engineer` |
| Department filter | `department` | Limit rows by department or function. | `Engineering` |
| Location / country | `location` | Match hiring country, region, or location text. | `United States` |
| Seniority | `seniority` | Filter by seniority values exposed by Remote.com. | `senior` |
| Maximum jobs | `limit` | Cap saved job records for cost control and test runs. | `25` |
| Include description snippet | `includeDescription` | Fetch detail pages for a best-effort description snippet. | `false` |

Use broad filters first, then narrow by department, location, or seniority once you confirm the result shape.

### Example input

```json
{
  "startUrls": [{ "url": "https://remote.com/jobs/all" }],
  "query": "engineer",
  "location": "United States",
  "limit": 25,
  "includeDescription": false
}
```

### Example output

```json
{
  "title": "Application Support Engineer",
  "company": "Example Company",
  "department": "IT Services",
  "location": "Germany",
  "remoteType": "remote",
  "seniority": ["mid_level"],
  "employmentType": "full_time",
  "deadline": "2026-06-30",
  "compensationMin": 46000,
  "compensationMax": 55000,
  "currency": "EUR",
  "visaSponsorshipOffered": false,
  "quickApply": true,
  "jobUrl": "https://remote.com/jobs/example-job",
  "applyUrl": "https://remote.com/jobs/example-job",
  "postedAt": "2026-06-15T14:19:41Z",
  "updatedAt": "2026-06-15T14:19:41",
  "source": "Remote.com"
}
```

### Tips for better results

- Start with the default all-jobs URL.
- Use a low limit for the first test run.
- Use broad keywords before narrow filters.
- Remove filters if you receive fewer jobs than expected.
- Schedule recurring runs to monitor new openings over time.
- Export CSV for spreadsheets and JSON for pipelines.

### Integrations

Remote.com Jobs Scraper works with Apify integrations and webhooks.

You can:

- Send new jobs to Google Sheets.
- Trigger Slack alerts for matching roles.
- Feed records into Airtable.
- Export JSON to a data warehouse.
- Use Make or Zapier to route matching jobs to newsletters.
- Schedule daily monitoring for specific departments.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/remote-dot-com-jobs-scraper').call({
  startUrls: [{ url: 'https://remote.com/jobs/all' }],
  query: 'engineer',
  limit: 25
});

console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/remote-dot-com-jobs-scraper').call(run_input={
    'startUrls': [{'url': 'https://remote.com/jobs/all'}],
    'query': 'engineer',
    'limit': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~remote-dot-com-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://remote.com/jobs/all"}],"query":"engineer","limit":25}'
```

### MCP and AI agents

Use this actor from Apify MCP-compatible clients.

MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/remote-dot-com-jobs-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-remote-jobs https://mcp.apify.com/?tools=fetch_cat/remote-dot-com-jobs-scraper
```

Example MCP server JSON configuration:

```json
{
  "mcpServers": {
    "apify-remote-jobs": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/remote-dot-com-jobs-scraper"
    }
  }
}
```

Example prompts for MCP clients:

- "Run Remote.com Jobs Scraper for product roles and create a shortlist of companies with salary ranges."
- "Find Remote.com jobs open to global candidates and group them by department, seniority, and compensation currency."
- "Monitor Remote.com for senior engineering jobs every week and summarize new apply URLs for my recruiting team."
- "Find engineering roles in Germany and summarize the top companies hiring this week."
- "Run Remote.com Jobs Scraper for jobs with visa sponsorship and prepare a CSV-ready table with title, company, location, compensation, and apply URL."

### Scheduling

You can schedule this actor to run daily, weekly, or monthly.

Useful schedules include:

- Daily engineering role monitoring
- Weekly sales and marketing hiring reports
- Monthly compensation trend snapshots
- Newsletter lead collection before publishing day

### Webhooks

Use Apify webhooks to trigger downstream workflows when a run succeeds.

Common webhook actions:

- Send dataset items to a database.
- Notify a Slack channel.
- Start another enrichment actor.
- Update a no-code automation workflow.

### Data quality notes

The actor extracts fields available from public Remote.com job listings.

Some jobs may not include compensation.

Some jobs may not include an external apply URL.

If quick apply is available, the job URL is used as the apply destination.

### FAQ

#### Can I use the API?

Yes. Use the Apify API examples above or connect through Apify MCP.

#### Can I schedule recurring monitoring?

Yes. Schedule the actor daily or weekly and export only the new rows your workflow needs.

### Troubleshooting

#### Why did I get zero results?

Your filters may be too narrow. Remove `query`, `department`, `location`, or `seniority` and try again.

#### Why is compensation empty for some jobs?

Remote.com does not expose a compensation range for every public listing.

#### Why is description empty?

Descriptions are optional and best effort. Turn on `includeDescription` if you need snippets, but keep it off for faster large runs.

### Legality and responsible use

This actor extracts publicly available job listing information.

You are responsible for using the data in compliance with applicable laws, Remote.com terms, and privacy rules.

Do not use scraped data for spam or discriminatory hiring practices.

### Related scrapers

You may also find these Apify actors useful:

- [RemoteOK Jobs Scraper](https://apify.com/fetch_cat/remoteok-jobs-scraper)
- [ATS Jobs Scraper](https://apify.com/fetch_cat/ats-jobs-scraper)
- [Lever Jobs Scraper](https://apify.com/fetch_cat/lever-jobs-scraper)
- [Workday Jobs Scraper](https://apify.com/fetch_cat/workday-jobs-scraper)
- [Ashby Jobs Scraper](https://apify.com/fetch_cat/ashby-jobs-scraper)

### Support

If your run fails or you need a field that is visible on Remote.com but missing from the dataset, open an issue from the actor page and include your run ID plus:

- **Input JSON** - the exact input you used, with private values removed if needed.
- **Expected output** - the jobs or fields you expected to receive.
- **Actual output** - a short sample of the rows or error you received.
- **Reproducible public URL** - a Remote.com jobs URL that shows the missing or incorrect data.

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

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

Remote.com jobs listing URLs to scrape. Leave the prefilled all-jobs URL to collect from the main public board.

## `query` (type: `string`):

Optional keyword matched against job title, company, department, seniority, and location.

## `department` (type: `string`):

Optional Remote.com department filter, for example Engineering, Sales, Marketing, or Customer Support.

## `location` (type: `string`):

Optional location text filter, for example United States, Germany, South Africa, or Europe.

## `seniority` (type: `string`):

Optional seniority filter such as entry\_level, mid\_level, senior, manager, or director.

## `limit` (type: `integer`):

Maximum number of matching Remote.com jobs to save.

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

Fetch each job detail page and save a best-effort description snippet. Keep off for faster large runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://remote.com/jobs/all"
    }
  ],
  "query": "engineer",
  "limit": 20,
  "includeDescription": false
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://remote.com/jobs/all"
        }
    ],
    "query": "engineer",
    "limit": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/remote-dot-com-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 = {
    "startUrls": [{ "url": "https://remote.com/jobs/all" }],
    "query": "engineer",
    "limit": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/remote-dot-com-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 '{
  "startUrls": [
    {
      "url": "https://remote.com/jobs/all"
    }
  ],
  "query": "engineer",
  "limit": 20
}' |
apify call fetch_cat/remote-dot-com-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/t7ukQgSb9aNr0CFuc/builds/Tc4IeQ5qKeHL80vOr/openapi.json