# We Work Remotely Scraper — Remote Jobs (`haketa/weworkremotely-scraper`) Actor

Scrape remote jobs from We Work Remotely: company, job title, region, category, full description, headquarters and apply link. Paste one or more WWR category URLs.

- **URL**: https://apify.com/haketa/weworkremotely-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.75 / 1,000 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/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

## We Work Remotely Scraper — Remote Jobs, Companies, Regions & Descriptions 🌐

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/weworkremotely-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg?style=flat-square)](https://apify.com/haketa/weworkremotely-scraper)
[![Output Format](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](https://apify.com/haketa/weworkremotely-scraper)
[![Talent Intelligence](https://img.shields.io/badge/Jobs-Remote%20Hiring%20Intelligence-purple?style=flat-square)](https://apify.com/haketa/weworkremotely-scraper)
[![Global Coverage](https://img.shields.io/badge/Coverage-Worldwide%20Remote%20Roles-brightgreen?style=flat-square)](https://apify.com/haketa/weworkremotely-scraper)

**Extract 100% remote job listings, company profiles, regional hiring requirements, and complete job descriptions from We Work Remotely at scale — no coding, no login, and no browser overhead.** This enterprise-grade **We Work Remotely scraper** extracts clean, structured remote-work data across all technical and non-technical categories: **hiring company name, job title, geographical eligibility region (e.g. Anywhere in the World, USA Only, Europe Only), job category taxonomy, company corporate headquarters, company website/application link, full plain-text job description, posting ID, published date, and direct application URL.**

Export clean datasets directly to **JSON, CSV, Excel, XML, or ingest via the Apify REST API, Python SDK, or Node.js client.**

> Built for **remote job board aggregators, recruitment agencies, tech talent sourcers, labor market researchers, B2B lead generators, and HR tech platforms.**

***

### ⚡ At a glance

| Feature | Specification |
|:---|:---|
| **Data Source** | We Work Remotely (`weworkremotely.com`) remote employment portal |
| **Coverage Scope** | All technical, creative, sales, executive, and support remote categories |
| **Input Flexibility** | Accepts full category URLs, short category slugs, or empty run for all categories |
| **Output Formats** | JSON, CSV, XLSX, XML, RSS, HTML Table |
| **Data Granularity** | Full plain-text job description (clean text, no HTML tags, ~4,000–8,000 chars) |
| **Differentiators** | Isolated Company HQ and Company Apply URL parsed from job postings |
| **Deduplication** | Strict entity deduplication across cross-listed multi-category jobs |
| **Throughput Speed** | ~50–100 remote jobs per second |
| **Default Proxy** | Datacenter Apify Proxy (fully supported out of the box) |

***

### 🔎 Why scrape We Work Remotely?

We Work Remotely (WWR) is the original and most visited remote-work community on the web, hosting active job postings from pioneering distributed companies, high-growth tech startups, and multinational software enterprises (such as Automattic, GitLab, Databricks, DuckDuckGo, and Basecamp).

Unlike general job aggregators that mislabel hybrid or on-site roles as "remote-friendly," every single listing on We Work Remotely is **100% remote by contract**:

1. **Pre-Filtered Remote Purity**: Zero clutter from local hybrid positions or mandatory office commutes.
2. **Clear Regional Guardrails**: Every listing explicitly states whether candidates must reside in `Anywhere in the World`, `USA Only`, `Europe Only`, or specific time zones.
3. **High-Growth Corporate Signals**: Companies paying premium fees to list on WWR have active recruitment budgets, venture backing, and distributed hiring initiatives.
4. **Complete Job Descriptions**: Listings include comprehensive responsibilities, requirement checklists, tech stacks, and company perks.

Manual harvesting from WWR is time-consuming and fragile. Listings are scattered across a dozen distinct category hubs, requiring endless navigation and copy-pasting.

This **We Work Remotely jobs scraper** extracts, cleans, deduplicates, and structures all current openings across every category into a unified data table in seconds.

***

### 🚀 Key features & capabilities

- 🎯 **All Job Categories Supported**: Scrape Programming (Full-Stack, Backend, Frontend), DevOps & Sysadmin, Product Design, Customer Support, Sales & Marketing, Management & Finance, Product Management, and Copywriting.
- 🌍 **Geographic Region Filtering**: Capture whether a position accepts candidates worldwide or restricts hiring to specific countries or continents.
- 🏢 **Company Firmographics**: Isolates the hiring organization's global headquarters (`headquarters`) and primary company URL (`companyUrl`).
- 📝 **Clean Plain-Text Descriptions**: Automatically strips HTML tags, decodes special entities, and cleans formatting to yield clean, LLM-ready markdown/text descriptions.
- 🔄 **Unlocked 1,000+ Deep Pagination**: Smoothly traverses through all category feeds to export exhaustive job boards without arbitrary item cutoffs.
- 🛡️ **Cross-Category Deduplication**: Guarantees that roles listed in multiple categories (e.g. Full-Stack and DevOps) are emitted only once, avoiding duplicate rows in your downstream pipeline.
- ⚡ **Ultra-Fast & Cost-Effective**: Operates without browser bloat, pulling hundreds of enriched job listings in under 30 seconds for a fraction of a cent.

***

### 📊 Extracted fields & data dictionary

Every record returned by the scraper contains complete job metadata:

#### 💼 Position & Organization

| Field | Type | Description | Coverage |
|:---|:---|:---|:---:|
| `company` | String | Hiring company or organization name | 🟢 High (100%) |
| `jobTitle` | String | Clean position title | 🟢 High (100%) |
| `region` | String | Allowed candidate location (e.g. `Anywhere in the World`, `USA Only`) | 🟢 High (100%) |
| `category` | String | Job functional category or specialized department | 🟢 High (100%) |
| `headquarters` | String | Physical city/country of corporate headquarters | 🟢 High (95%) |
| `companyUrl` | String | External website or direct applicant portal link | 🟢 High (90%) |

#### 📄 Job Description & System Metadata

| Field | Type | Description | Coverage |
|:---|:---|:---|:---:|
| `description` | String | Comprehensive plain-text job requirements and overview | 🟢 High (100%) |
| `jobId` | String | Unique WWR job posting identifier / slug | 🟢 High (100%) |
| `url` | String | Canonical URL to the live job posting on We Work Remotely | 🟢 High (100%) |
| `publishedDate` | String | Original publication date and time | 🟢 High (100%) |
| `scrapedAt` | String | ISO 8601 data collection timestamp | 🟢 High (100%) |

***

### 💻 Sample output (JSON)

```json
{
  "company": "Sticker Mule",
  "jobTitle": "Senior Full-Stack Engineer",
  "region": "Anywhere in the World",
  "category": "Full-Stack Programming",
  "headquarters": "Amsterdam, New York",
  "companyUrl": "https://www.stickermule.com",
  "description": "Sticker Mule is looking for a talented Senior Full-Stack Engineer to help build delightful e-commerce experiences for millions of customers worldwide.\n\nResponsibilities:\n- Design, develop, and maintain performant web applications using TypeScript, React, and Node.js.\n- Collaborate closely with product managers and UX designers to ship high-impact features weekly.\n- Optimize PostgreSQL queries and Redis caching layers for high-concurrency checkout flows.\n\nRequirements:\n- 5+ years of production experience in modern full-stack web development.\n- Deep familiarity with distributed systems, RESTful APIs, and cloud deployments.\n- Strong written communication skills and comfort working asynchronously across global time zones.",
  "jobId": "1049281",
  "url": "https://weworkremotely.com/remote-jobs/sticker-mule-senior-full-stack-engineer",
  "publishedDate": "Mon, 09 Nov 2026 14:20:00 +0000",
  "scrapedAt": "2026-11-10T14:50:00.000Z"
}
```

***

### 🎯 High-impact use cases

#### 1. Powering Automated Remote Job Boards

Feed fresh, deduplicated job postings directly into your specialized niche job portal (e.g. "Remote Elixir Jobs" or "Europe-Only Tech Careers") using Apify scheduled tasks and Webhooks.

#### 2. B2B Sales Prospecting & Agency Lead Generation

Companies that actively hire remote developers, designers, and marketers are expanding operations and investing in tools. Reach out to offer distributed HR software, developer tooling, contractor payroll services, or design agency support.

#### 3. Recruitment Sourcing & Talent Matching

Staffing agencies and headhunters can monitor newly posted roles to identify companies struggling with hard-to-fill technical vacancies, presenting pre-vetted candidates before competitors reach out.

#### 4. Labor Market & Compensation Research

Mine thousands of job descriptions for emerging technology requirements (e.g. AI agents, Rust, vector databases) and regional hiring shifts (e.g. growth of LATAM vs EMEA remote hiring).

#### 5. AI Training Corpora & Resume Matching Models

Use cleaned, structured job description texts to train NLP classification algorithms, resume-scoring systems, and semantic job recommendation engines.

***

### ⚙️ Input configuration

| Field | Type | Default | Description |
|:---|:---|:---:|:---|
| `startUrls` | Array\[String] | Popular Categories | List of WWR category URLs or slugs to scrape. Leave empty to crawl all major categories. |
| `maxItems` | Integer | `0` | Total maximum jobs across all categories. `0` = unlimited (governed by total available postings). |
| `proxyConfiguration` | Object | Datacenter | Apify Proxy configuration. Datacenter proxy provides high reliability and speed. |

***

### 🗺️ Supported category URLs reference

You can paste any of the following URLs or simple slugs into `startUrls`:

| Category Name | Full Category URL | Category Slug |
|:---|:---|:---|
| **Programming (All)** | `https://weworkremotely.com/categories/remote-programming-jobs` | `remote-programming-jobs` |
| **Design** | `https://weworkremotely.com/categories/remote-design-jobs` | `remote-design-jobs` |
| **DevOps & Sysadmin** | `https://weworkremotely.com/categories/remote-devops-sysadmin-jobs` | `remote-devops-sysadmin-jobs` |
| **Customer Support** | `https://weworkremotely.com/categories/remote-customer-support-jobs` | `remote-customer-support-jobs` |
| **Sales & Marketing** | `https://weworkremotely.com/categories/remote-sales-and-marketing-jobs` | `remote-sales-and-marketing-jobs` |
| **Management & Finance**| `https://weworkremotely.com/categories/remote-management-and-finance-jobs` | `remote-management-and-finance-jobs` |
| **Product** | `https://weworkremotely.com/categories/remote-product-jobs` | `remote-product-jobs` |
| **Copywriting** | `https://weworkremotely.com/categories/remote-copywriting-jobs` | `remote-copywriting-jobs` |
| **Exec & Business** | `https://weworkremotely.com/categories/remote-business-exec-management-jobs`| `remote-business-exec-management-jobs` |

***

### 🛠️ Code examples

#### Python (apify-client)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run_input = {
    "startUrls": [
        "https://weworkremotely.com/categories/remote-programming-jobs",
        "https://weworkremotely.com/categories/remote-devops-sysadmin-jobs"
    ],
    "maxItems": 100,
}

run = client.actor("haketa/weworkremotely-scraper").call(run_input=run_input)
jobs = client.dataset(run["defaultDatasetId"]).list_items().items

for job in jobs:
    print(f"[{job.get('region')}] {job.get('company')} — {job.get('jobTitle')} ({job.get('headquarters')})")
```

#### Node.js (apify-client)

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

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const run = await client.actor('haketa/weworkremotely-scraper').call({
    startUrls: ['https://weworkremotely.com/categories/remote-programming-jobs'],
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} remote developer positions!`);
```

***

### 💡 Practical tips for optimal runs

- **Scrape All Roles**: Leave `startUrls` empty or supply empty array `[]` to automatically crawl all nine core remote categories across the entire platform.
- **Filter by Worldwide Eligibility**: In your downstream database or Google Sheet, filter on `region: "Anywhere in the World"` for positions open to global applicants without residency restrictions.
- **Deduplication Across Categories**: If a hiring company posts a role in both `Programming` and `DevOps`, the actor's internal deduplication ensures it appears only once in your export.
- **Automated Alerts**: Connect the actor to Slack via Make or Zapier to receive instant alerts whenever high-profile tech brands publish new positions.

***

### ❓ Frequently asked questions (FAQ)

##### Are all jobs scraped from We Work Remotely truly remote?

Yes. We Work Remotely exclusively accepts 100% remote positions. There are no mandatory on-site office requirements for any listing on the platform.

##### How does the `region` field work?

Companies define geographic eligibility in the `region` property. Common values include `Anywhere in the World`, `USA Only`, `Europe Only`, `Americas Only`, or specific state/country combinations.

##### Does the scraper extract the full job description?

Yes. Unlike simple job board scrapers that only extract brief summaries, this actor captures the entire job description text (typically 3,000 to 10,000 characters) with HTML markup cleanly stripped.

##### How many jobs can I scrape in a single execution?

You can scrape all currently active positions across all platform categories. With `maxItems: 0`, the scraper extracts every live listing (typically 400 to 800+ total roles across the site).

##### What export formats are supported?

You can download scraped listings from the Apify Console as JSON, CSV, Microsoft Excel (XLSX), XML, or an HTML table. You can also fetch records directly via the Apify Dataset API.

##### Does this scraper require a We Work Remotely account?

No. The scraper queries publicly available category directories without requiring an account, employer login, or paid subscription.

##### Can I schedule automatic daily updates?

Yes. Use the Apify Schedules feature to execute the scraper automatically every morning, ensuring your job board or recruiting pipeline always has the newest listings.

##### How fresh is the data?

Data is fetched live at the moment of execution. The `publishedDate` field gives the exact timestamp when the employer published the role.

##### Does the scraper work with Apify Proxy?

Yes. Apify Datacenter Proxy is supported and enabled by default, ensuring high reliability and rapid network response times.

##### How do I get only technical or developer jobs?

Supply `https://weworkremotely.com/categories/remote-programming-jobs` and `https://weworkremotely.com/categories/remote-devops-sysadmin-jobs` in `startUrls`.

***

### 🔄 Integrations & automated workflows

#### Live Remote Job Board Sync (Airtable / Webflow)

1. Configure an Apify scheduled run to execute every 6 hours.
2. Connect Apify to Webflow via Make (Integromat).
3. Map `jobTitle` ➔ Title, `company` ➔ Employer, `region` ➔ Location, `description` ➔ Rich Text, `url` ➔ Application Link.
4. Keep your Webflow remote job board completely automated without manual publishing.

#### Slack / Discord Hiring Alerts

1. Set up an Apify Webhook that triggers upon actor completion.
2. Filter for roles where `region` contains `"Anywhere in the World"`.
3. Post formatted markdown alerts to your community Discord or company recruitment Slack channel.

***

### 📈 Performance & scalability benchmarks

| Scope | Category Feeds | Approx. Execution Time | Memory Required | Est. Cost Profile |
|:---:|:---:|:---:|:---:|:---:|
| **50 jobs** (Single Category) | 1 Category | ~5–10 seconds | 512 MB | ~$0.001 |
| **150 jobs** (Core Tech) | 3 Categories | ~15–25 seconds | 512 MB | ~$0.003 |
| **400+ jobs** (Full Platform) | All Categories | ~35–60 seconds | 512 MB | ~$0.007 |

***

### 🔗 Related scrapers

- [Welcome to the Jungle Company Scraper](https://apify.com/haketa/wttj-companies-scraper) — Tech company firmographics, stack & hiring signals.
- [Eventbrite Scraper](https://apify.com/haketa/eventbrite-scraper) — Extract business events and organizer leads.
- [Czech Company Registry Scraper for ARES](https://apify.com/haketa/czech-ares-scraper) — Official Czech business entity verification.
- [Shopify Store Scraper](https://apify.com/haketa/shopify-store-scraper) — E-commerce product catalogs and variant pricing.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlimited Extraction & Zero Limit**: Set `maxItems` to default `0` (unlimited, governed only by total current jobs).
- **Graceful Empty Run Fallback**: Added default multi-category fallback (`DEFAULT_FEEDS`), guaranteeing empty inputs return all current listings across all major departments.
- **Fast Prefill Optimization**: Streamlined prefill run times to under 15 seconds for rapid testing.
- **Description HTML Normalization**: Upgraded entity decoding and whitespace cleanup for clean LLM-ready text output.
- **HQ & Company URL Extraction**: Enhanced regex patterns to reliably isolate employer headquarters and application links.

#### v1.1

- Added support for all new WWR categories and sub-slugs.
- Improved cross-category entity deduplication.

#### v1.0

- Initial release featuring category feed parsing, plain-text description cleaning, and JSON/CSV exports.

***

### 🗺️ Decoding remote candidate eligibility regions

We Work Remotely employers specify candidate location parameters in the `region` field. Understanding these values helps you filter relevant opportunities:

| Region Value | Scope & Restrictions | Best Suited For |
|:---|:---|:---|
| **Anywhere in the World** | 100% global eligibility; no nationality, legal residency, or timezone prerequisites | Worldwide digital nomads, international contractors |
| **USA Only** | Requires US legal work authorization or US residency | US citizens, Green Card holders, US-based contractors |
| **Europe Only** | Restricted to candidates residing across European timezones (CET/GMT ± 2) | European developers, EU residents, UK professionals |
| **Americas Only** | Open to North, Central, and South America (PST to EST timezones) | LATAM and North American engineers working shared core hours |
| **Canada Only** | Requires Canadian residency or provincial tax status | Canadian remote workers |
| **Specific Timezone Bands** | Examples: `UTC-5 to UTC+1`, `PST to EST` | Teams requiring 4–6 hours of synchronous daily overlap |

***

### 🧠 Semantic search & LLM resume matching pipeline

Clean plain-text descriptions extracted by this actor are ideal for embedding and retrieval-augmented generation (RAG) pipelines:

#### 1. Vector Database Ingestion (Pinecone / Chroma / Qdrant)

- Pass the cleaned `description` text through an embedding model (e.g., OpenAI `text-embedding-3-small` or Cohere `embed-english-v3.0`).
- Store vector embeddings alongside metadata: `company`, `jobTitle`, `region`, `category`, `url`.
- Enable semantic natural language search: *"Find remote roles for senior backend engineers with distributed systems and Go experience."*

#### 2. Automated Candidate-to-Job Matching

- Embed applicant resumes and calculate cosine similarity against freshly scraped jobs.
- Filter on `region` matching the candidate's current residence.
- Rank active vacancies by match score and automatically email tailored alerts to registered talent.

#### 3. Emerging Skills Trend Extraction

- Run periodic keyword extraction across all active descriptions to identify shifts in framework demand (e.g. rising mentions of Next.js 15, FastAPI, LangChain, or Kubernetes).
- Track quarter-over-quarter growth rates of remote hiring demand across programming languages.

***

### 💼 Category breakdown & career specialization

We Work Remotely organizes its job postings into specialized career tracks. You can target individual sub-feeds or capture all areas simultaneously:

#### 1. Programming & Software Development

The largest category on WWR, featuring high-compensation engineering roles across:

- **Full-Stack Development**: Modern JavaScript/TypeScript stacks (React, Vue, Node.js), Ruby on Rails, Django, Laravel.
- **Backend Architecture**: High-throughput distributed systems in Go, Rust, Java, Python, and C#.
- **Frontend Engineering**: UI/UX performance optimization, Next.js, Tailwind, component design systems.
- **Mobile Development**: Native iOS (Swift), Android (Kotlin), and cross-platform Flutter/React Native engineers.

#### 2. DevOps, Cloud & Systems Administration

Crucial roles for scaling distributed cloud infrastructure:

- Cloud Platform Engineers (AWS, GCP, Azure).
- Kubernetes, Terraform, CI/CD automated pipeline orchestration.
- Site Reliability Engineering (SRE) and 24/7 observability architecture.

#### 3. Product, Design & User Experience

Creative roles shaping digital user experiences:

- Product Designers and UI/UX Specialists (Figma, design systems).
- Product Managers (scrum, user research, roadmapping, data analytics).
- User Researchers and Information Architects.

#### 4. Sales, Marketing & Customer Support

Essential growth and customer retention positions:

- Account Executives, SDRs, and Enterprise Partnership Leads.
- Content Strategists, SEO Specialists, and Growth Marketers.
- Technical Support Engineers and Tier-2 Customer Success Managers.

#### 5. Management, Operations & Finance

Operational leadership for distributed teams:

- Chief of Staff, Head of Remote Operations, People & Culture Leads.
- Fractional CFOs, Financial Controllers, and International Payroll Specialists.

***

### 🔒 Responsible data usage notice

This actor extracts publicly accessible job vacancy announcements published on We Work Remotely for legitimate employment aggregation, talent sourcing, and labor market research. This tool is an independent utility and is not officially affiliated with, endorsed by, or sponsored by We Work Remotely.

*All trademarks, logos, and brand names are the property of their respective owners.*

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/weworkremotely-scraper/changelog.md

# Actor input Schema

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

We Work Remotely category URLs, e.g. https://weworkremotely.com/categories/remote-programming-jobs . Categories include: remote-programming-jobs, remote-design-jobs, remote-devops-sysadmin-jobs, remote-customer-support-jobs, remote-sales-and-marketing-jobs, remote-management-and-finance-jobs, remote-product-jobs, remote-copywriting-jobs, remote-business-exec-management-jobs. Leave empty to scrape all popular categories.

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

Maximum number of jobs across all categories. 0 = unlimited.

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

Apify Proxy. Datacenter is enough for We Work Remotely and is enabled by default; add residential only if you hit rate limits.

## Actor input object example

```json
{
  "startUrls": [
    "https://weworkremotely.com/categories/remote-programming-jobs",
    "https://weworkremotely.com/categories/remote-design-jobs"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `company` (type: `string`):

Hiring company

## `jobTitle` (type: `string`):

Job title

## `region` (type: `string`):

Allowed region (e.g. Anywhere / USA Only)

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

Job category

## `headquarters` (type: `string`):

Company HQ location

## `companyUrl` (type: `string`):

Company / apply URL

## `description` (type: `string`):

Full job description (text)

## `jobId` (type: `string`):

Job slug / ID

## `url` (type: `string`):

Job posting URL

## `publishedDate` (type: `string`):

Posted date

## `scrapedAt` (type: `string`):

ISO timestamp

# 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": [
        "https://weworkremotely.com/categories/remote-programming-jobs",
        "https://weworkremotely.com/categories/remote-design-jobs"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "startUrls": [
        "https://weworkremotely.com/categories/remote-programming-jobs",
        "https://weworkremotely.com/categories/remote-design-jobs",
    ],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/weworkremotely-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 '{
  "startUrls": [
    "https://weworkremotely.com/categories/remote-programming-jobs",
    "https://weworkremotely.com/categories/remote-design-jobs"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/weworkremotely-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/weworkremotely-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/WYBmC8o2plkWjrlHm/builds/1CAC5io3IN504ZGgX/openapi.json