# We Work Remotely Scraper (`jungle_synthesizer/weworkremotely-scraper`) Actor

Scrape remote job listings from WeWorkRemotely.com. Extract job titles, company names, salaries, categories, job types, apply URLs, and tags. Filter by category (Programming, Design, DevOps, etc.) and job type. Built for recruiters, job aggregators, and workforce analytics teams.

- **URL**: https://apify.com/jungle\_synthesizer/weworkremotely-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (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

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## We Work Remotely Job Listings Scraper

Scrape job listings from [WeWorkRemotely.com](https://weworkremotely.com) — the largest remote-only job board. Returns job titles, company names, salaries (parsed min/max), categories, employment types, location restrictions, and listing URLs for all ~180 current openings across 10 categories.

---

### We Work Remotely Scraper Features

- Extracts all active job listings from WeWorkRemotely.com in a single run
- Filters by category (Programming, Design, DevOps & Sysadmin, Sales & Marketing, and 6 others)
- Filters by employment type (Full-Time, Contract, Part-Time)
- Keyword search across job titles and tags
- Parses structured salary data — minimum, maximum, and currency — from free-text salary badges
- Returns company headquarters location when listed
- Includes company logo URLs for enriched display
- No proxies needed. No browser rendering. Fast, clean HTML extraction from a server-rendered site.

---

### What Can You Do With We Work Remotely Data?

- **Recruiters & talent acquisition teams** — Monitor remote job market trends, benchmark salary ranges, and identify which companies are actively hiring in a given category.
- **Job aggregators and listing platforms** — Ingest structured remote job data into your own job board or alert system without manual curation.
- **Salary benchmarking tools** — Extract salary ranges across roles and categories to power compensation analytics, especially useful for remote-first roles that often post salary openly.
- **Workforce analytics researchers** — Track hiring velocity by category, company size, or location restriction to understand remote work market shifts.
- **Lead generation for B2B SaaS** — Identify companies growing remote engineering or sales teams as high-intent prospects for tooling, HR platforms, or benefits providers.
- **Career coaching and job-seeking tools** — Build curated job feeds filtered by category and type for specific candidate profiles.

---

### How We Work Remotely Scraper Works

1. **Configure your filters.** Select a category (or leave empty for all categories), an employment type, and optionally a keyword to search job titles and tags.
2. **The scraper fetches the listing pages.** WWR's homepage groups all active jobs by category in clean server-rendered HTML — the scraper processes them in one efficient pass.
3. **Data is extracted from each listing card.** Job title, company name, headquarters, salary badge, location restriction, and tags are parsed from the HTML.
4. **Results land in your dataset.** Each record is a structured JSON object. Salary is parsed into numeric min/max fields with currency. Tags are pipe-separated strings.

---

### Input

```json
{
  "category": "programming",
  "jobType": "full-time",
  "searchKeyword": "python",
  "maxItems": 50
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `category` | String | All categories | Filter by job category. Options: `programming`, `design`, `copywriting`, `devops-sysadmin`, `customer-support`, `sales-marketing`, `business-exec-management`, `finance-legal`, `product`, `all-other-remote`. |
| `jobType` | String | All types | Filter by employment type. Options: `full-time`, `contract`, `part-time`. |
| `searchKeyword` | String | — | Search for jobs by keyword. Matches against job titles and tags. |
| `listingUrls` | Array | — | Specific We Work Remotely job listing URLs to scrape directly, bypassing category crawling. |
| `maxItems` | Integer | 10 | Maximum number of job listings to return. Set to `0` for unlimited. |

**Scrape a specific category with no limit:**

```json
{
  "category": "design",
  "maxItems": 0
}
```

***

### We Work Remotely Scraper Output Fields

```json
{
  "job_title": "Senior Full Stack Engineer",
  "company_name": "Automattic",
  "company_logo_url": "https://we-work-remotely.imgix.net/logos/0001/0001/logo.gif?ixlib=rails-4.0.0&w=50&h=50",
  "category": "Back-End Programming",
  "job_type": "Full-Time",
  "salary_min": 120000,
  "salary_max": 170000,
  "salary_currency": "USD",
  "location_restriction": "Anywhere in the World",
  "description": null,
  "apply_url": null,
  "posted_date": null,
  "tags": "WordPress | PHP | React",
  "remote_type": "fully_remote",
  "company_hq": "San Francisco, CA",
  "listing_url": "https://weworkremotely.com/remote-jobs/automattic-senior-full-stack-engineer"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `job_title` | String | Job title as listed on the posting |
| `company_name` | String | Name of the hiring company |
| `company_logo_url` | String | URL of the company logo image |
| `category` | String | Job category (Back-End Programming, Design, etc.) |
| `job_type` | String | Employment type (Full-Time, Contract, Part-Time) |
| `salary_min` | Number | Minimum salary parsed from the listing badge (annual) |
| `salary_max` | Number | Maximum salary parsed from the listing badge (annual) |
| `salary_currency` | String | Salary currency code (USD, EUR, GBP, etc.) |
| `location_restriction` | String | Geographic restriction or "Anywhere in the World" for unrestricted |
| `description` | String | Full job description text (currently null — detail pages require different access) |
| `apply_url` | String | Direct application URL (currently null — detail pages require different access) |
| `posted_date` | String | ISO 8601 posting date (currently null — not present on listing cards) |
| `tags` | String | Skill tags and badges from the listing card, pipe-separated |
| `remote_type` | String | Remote arrangement (fully\_remote or hybrid) |
| `company_hq` | String | Company headquarters location when listed |
| `listing_url` | String | Full We Work Remotely listing URL |

***

### FAQ

#### How many jobs does WeWorkRemotely.com have?

WeWorkRemotely.com maintains around 150-200 active job listings at any time across all categories. The site is curated rather than aggregated, so volume is lower than generalist boards — but listing quality is high and all roles are remote.

#### Why are description, apply\_url, and posted\_date null?

These fields are only available on individual job detail pages. The listing cards on category pages contain all commercially useful structured fields — title, company, salary, category, location, and tags. The null fields are included in the schema for completeness and forward compatibility.

#### Does this scraper need proxies?

No. WeWorkRemotely.com serves its listing pages as clean server-rendered HTML without requiring proxies. Set up and run in seconds.

#### How often should I run this scraper?

We Work Remotely posts new jobs daily while maintaining a stable total count. Running once or twice daily catches fresh listings. Use `listing_url` as a deduplication key across runs.

#### Can I scrape only a specific job category?

Yes. Set the `category` input to one of: `programming`, `design`, `copywriting`, `devops-sysadmin`, `customer-support`, `sales-marketing`, `business-exec-management`, `finance-legal`, `product`, or `all-other-remote`. Leave empty to scrape all categories.

***

### Need More Features?

Open a feature request or contact us through the Apify platform — we respond to all improvement suggestions.

### Why Use We Work Remotely Scraper?

- **Priced at $0.001/record** — 12x cheaper than the leading PPE competitor ($0.012/item), and more cost-effective than flat-rate alternatives for typical run sizes.
- **Structured salary parsing** — `salary_min`, `salary_max`, and `salary_currency` extracted from free-text badges. Most competitors return raw salary strings that require post-processing.
- **Category and type filters** — target exactly the job segment you need without downloading everything and filtering client-side.
- **No operational overhead** — no proxy costs, no browser rendering, no rate limit tuning required.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `category` (type: `string`):

Filter by job category. Leave empty to scrape all categories.

## `jobType` (type: `string`):

Filter by employment type.

## `searchKeyword` (type: `string`):

Search for jobs by keyword (e.g. 'python', 'react', 'marketing'). Searches job titles and descriptions.

## `listingUrls` (type: `array`):

Specific We Work Remotely job listing URLs to scrape. Bypasses category crawling when provided.

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

Maximum number of job listings to return. Set to 0 for unlimited.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "listingUrls": [
    {
      "url": "https://weworkremotely.com/remote-jobs/view"
    }
  ],
  "maxItems": 10
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "category": "",
    "jobType": "",
    "searchKeyword": "",
    "listingUrls": [
        {
            "url": "https://weworkremotely.com/remote-jobs/view"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/weworkremotely-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "category": "",
    "jobType": "",
    "searchKeyword": "",
    "listingUrls": [{ "url": "https://weworkremotely.com/remote-jobs/view" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/weworkremotely-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "category": "",
  "jobType": "",
  "searchKeyword": "",
  "listingUrls": [
    {
      "url": "https://weworkremotely.com/remote-jobs/view"
    }
  ],
  "maxItems": 10
}' |
apify call jungle_synthesizer/weworkremotely-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "We Work Remotely Scraper",
        "description": "Scrape remote job listings from WeWorkRemotely.com. Extract job titles, company names, salaries, categories, job types, apply URLs, and tags. Filter by category (Programming, Design, DevOps, etc.) and job type. Built for recruiters, job aggregators, and workforce analytics teams.",
        "version": "1.0",
        "x-build-id": "JcClMmNFuHg0uncMa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~weworkremotely-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-weworkremotely-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/jungle_synthesizer~weworkremotely-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-weworkremotely-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/jungle_synthesizer~weworkremotely-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-weworkremotely-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": [
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "category": {
                        "title": "Job Category",
                        "enum": [
                            "",
                            "programming",
                            "design",
                            "copywriting",
                            "devops-sysadmin",
                            "customer-support",
                            "sales-marketing",
                            "business-exec-management",
                            "finance-legal",
                            "product",
                            "all-other-remote"
                        ],
                        "type": "string",
                        "description": "Filter by job category. Leave empty to scrape all categories."
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "",
                            "full-time",
                            "contract",
                            "part-time"
                        ],
                        "type": "string",
                        "description": "Filter by employment type."
                    },
                    "searchKeyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Search for jobs by keyword (e.g. 'python', 'react', 'marketing'). Searches job titles and descriptions."
                    },
                    "listingUrls": {
                        "title": "Job Listing URL(s)",
                        "type": "array",
                        "description": "Specific We Work Remotely job listing URLs to scrape. Bypasses category crawling when provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of job listings to return. Set to 0 for unlimited.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
