# We Work Remotely Jobs Scraper (`automation-lab/we-work-remotely-jobs-scraper`) Actor

🔎 Extract current We Work Remotely vacancies with full descriptions, requirements, restrictions, skills, company details, and public apply links.

- **URL**: https://apify.com/automation-lab/we-work-remotely-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
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 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Jobs Scraper

Collect current remote vacancies from [We Work Remotely](https://weworkremotely.com/) as clean JSON, CSV, Excel, XML, or RSS-ready data.

Search by keyword, combine category feeds, filter by region or recency, and enrich every vacancy with its full public job description and application link.

The Actor runs a real browser to handle the site's public Cloudflare delivery while keeping runs efficient by blocking images, media, fonts, ads, and analytics.

### What does We Work Remotely Jobs Scraper do?

We Work Remotely Jobs Scraper turns public WWR job pages into structured vacancy records.

It can:

- 🔎 Search titles, technologies, companies, and role keywords.
- 🗂️ Collect one or more public job categories.
- 🎯 Process exact WWR search, category, all-jobs, or job-detail URLs.
- 🌍 Filter cards by remote region or company location.
- 🕒 Keep only listings with a parseable recent posted age.
- 📄 Enrich jobs with descriptions, requirements, responsibilities, and benefits.
- 🧭 Capture timezone and geographic restrictions when they appear in the description.
- 🔗 Export canonical job, company, logo, and public application URLs.
- ♻️ Deduplicate jobs by canonical URL across combined sources.

The output is one dataset row per vacancy, ready for export or automation.

### Who is it for?

#### Recruiters and sourcers

Build a focused queue of remote candidates' opportunities by technology, seniority, category, or hiring region.

Use the public apply URL to route selected vacancies into a sourcing workflow.

#### Job aggregators

Refresh a WWR feed without copying pages by hand.

Canonical URLs and scrape timestamps make incremental ingestion and deduplication straightforward.

#### Talent intelligence teams

Compare demand for skills, locations, job types, and remote regions over time.

Store recurring datasets and load them into a warehouse or BI tool.

#### Developers and automation teams

Trigger scheduled searches through the Apify API, webhooks, integrations, or MCP.

Receive structured records instead of maintaining browser challenge logic.

### Why use this remote jobs scraper?

- ✅ **Full details:** get more than card titles and company names.
- ✅ **Flexible discovery:** combine keyword searches and exact category URLs.
- ✅ **Useful filters:** narrow by remote geography and listing age before export.
- ✅ **Public actions:** preserve source and application links for verification.
- ✅ **Browser-grade access:** use a route proven against current WWR delivery.
- ✅ **Cost control:** choose listing-only mode when full descriptions are unnecessary.
- ✅ **Typed output:** stable field names work with spreadsheets, APIs, and databases.

### What data can I extract from We Work Remotely?

| Field | Description |
|---|---|
| `title` | Public job title |
| `company` | Hiring company |
| `companyLocation` | Company headquarters shown on the listing |
| `category` | WWR category from the detail page |
| `employmentType` | Full-Time, Contract, or another displayed type |
| `remoteRegion` | Geographic remote-work region |
| `salaryText` | Salary badge when displayed |
| `postedText` | Source age such as `3d` |
| `postedDate` | Estimated ISO date derived from the displayed age |
| `applyBefore` | Public application deadline when displayed |
| `badges` | Featured, Boosted, Top 100, or similar labels |
| `skills` | Skills listed in the job sidebar |
| `description` | Full public role description |
| `requirements` | Extracted requirements section when identifiable |
| `responsibilities` | Extracted role or responsibilities section |
| `benefits` | Extracted benefits or offer section |
| `timezoneRestrictions` | Timezone sentence found in the description |
| `geographicRestrictions` | Geographic eligibility sentence when found |
| `applyUrl` | Public external Apply now action |
| `companyUrl` | WWR company profile URL |
| `companyLogoUrl` | Public logo or company image URL |
| `sourceUrl` | Canonical WWR job URL |
| `scrapedAt` | UTC extraction timestamp |

Fields absent from a source page are omitted rather than filled with misleading placeholders.

### How much does it cost to scrape We Work Remotely jobs?

The Actor uses pay-per-event pricing: a $0.005 one-time run-start event plus one event for each job saved.

| Apify tier | Price per job | Five jobs plus start |
|---|---:|---:|
| Free | $0.0073394 | about $0.0417 |
| Bronze | $0.0063821 | about $0.0369 |
| Silver | $0.004978 | about $0.0299 |
| Gold | $0.0038292 | about $0.0241 |
| Platinum | $0.0025528 | about $0.0178 |
| Diamond | $0.001787 | about $0.0139 |

A five-job prefilled run is intentionally small and suitable for evaluation.

Listing-only mode usually finishes faster than full-detail enrichment because it avoids one browser navigation per job.

Always use `maxItems` to cap a new workflow before scaling it.

### How to scrape We Work Remotely in 5 steps

1. Open the Actor input page.
2. Enter a keyword such as `python`, or add one or more WWR URLs.
3. Choose the maximum number of jobs and whether to include full details.
4. Optionally add a region or recency filter.
5. Click **Start** and export the default dataset when the run succeeds.

For recurring monitoring, save the input as an Apify task and attach a schedule.

### Input parameters

#### `keyword`

Creates a WWR public search URL.

Examples include `python`, `product designer`, `customer success`, and a company name.

#### `startUrls`

Accepts exact public URLs on `weworkremotely.com`.

Supported routes include search pages, category pages, the all-jobs page, and individual job pages.

Other hosts and unrelated WWR paths fail closed.

#### `categoryUrls`

Combines multiple WWR category feeds in one run.

Duplicate job links across sources are saved once.

#### `maxItems`

Limits unique dataset records from 1 to 1,000.

The prefill is five jobs to keep the first run quick.

#### `includeDetails`

When true, the Actor opens each job page and extracts all enrichment fields.

When false, it returns fast listing-card fields only.

#### `region`

Performs a case-insensitive text match against the remote region and company location shown on a card.

Examples: `Europe`, `United States`, or `Anywhere`.

#### `recencyDays`

Keeps cards whose displayed posted age can be converted to a date within the selected window.

Unparseable ages are excluded when this filter is active.

#### `proxyConfiguration`

Direct browser access is the default.

Configure Apify Proxy or custom proxies only when your workload repeatedly encounters a Cloudflare challenge.

### Example input

```json
{
  "keyword": "python",
  "maxItems": 10,
  "includeDetails": true,
  "region": "Anywhere",
  "recencyDays": 30
}
````

Category-monitor example:

```json
{
  "categoryUrls": [
    { "url": "https://weworkremotely.com/categories/remote-back-end-programming-jobs" }
  ],
  "maxItems": 25,
  "includeDetails": true
}
```

### Example output

```json
{
  "title": "Senior Backend Developer (Python)",
  "company": "Proxify AB",
  "companyLocation": "Sweden",
  "category": "Back-End Programming",
  "employmentType": "Full-Time",
  "remoteRegion": "Anywhere in the World",
  "postedText": "3d",
  "postedDate": "2026-07-13",
  "skills": ["Django", "Python"],
  "timezoneRestrictions": "Time zone: CET (+/- 3 hours).",
  "applyUrl": "https://career.example/apply",
  "sourceUrl": "https://weworkremotely.com/remote-jobs/example-role",
  "scrapedAt": "2026-07-16T02:21:19.841Z"
}
```

Real values change as WWR listings are updated.

### Listing-only versus full-detail mode

Use listing-only mode for frequent lightweight discovery, URL monitoring, or title/company feeds.

Use full-detail mode for recruiting research, requirements analysis, application workflows, and rich search indexing.

| Mode | Listing fields | Description and apply data | Relative runtime |
|---|---:|---:|---:|
| Listing only | Yes | No | Lower |
| Full details | Yes | Yes, when public | Higher |

A detail-page failure is logged.

If every requested detail fails, the run exits non-zero instead of claiming successful enrichment.

### Filtering and deduplication tips

- Start with a broad keyword and a low `maxItems`.
- Add `region` only after checking the exact labels WWR currently uses.
- Use `recencyDays` for daily or weekly monitor tasks.
- Combine category URLs when one sourcing feed needs several disciplines.
- Use `sourceUrl` as the durable deduplication key downstream.
- Compare `scrapedAt` with prior runs to identify refreshed records.
- Keep the original `postedText` because `postedDate` is an estimate from age text.

### Scheduling a remote-jobs monitor

Save a tested input as an Apify task.

Add an hourly, daily, or weekly schedule based on how quickly your workflow needs new vacancies.

Send the dataset to a webhook after each successful run.

In your destination, upsert by `sourceUrl` and retain the first-seen and last-seen timestamps.

Use a short recency window to reduce repeated records when appropriate.

### Integrations

#### Google Sheets

Use the Google Sheets integration to append new WWR records to a recruiting tracker.

Deduplicate on `sourceUrl` before notifying a recruiter.

#### Slack or Microsoft Teams

Attach a webhook that posts jobs matching selected skills or remote regions.

Include `title`, `company`, `remoteRegion`, and `applyUrl` in the message.

#### Zapier and Make

Trigger a workflow after the Actor finishes.

Route high-priority vacancies to an ATS, CRM, email alert, or review queue.

#### Airbyte, BigQuery, and warehouses

Export recurring datasets for skill-demand, location, company, and category trend analysis.

Keep historical snapshots rather than overwriting the latest feed.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/we-work-remotely-jobs-scraper').call({
  keyword: 'python',
  maxItems: 10,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/we-work-remotely-jobs-scraper').call(run_input={
    'keyword': 'python',
    'maxItems': 10,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~we-work-remotely-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"python","maxItems":10,"includeDetails":true}'
```

Fetch dataset items after the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use We Work Remotely Jobs Scraper with MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/we-work-remotely-jobs-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/we-work-remotely-jobs-scraper"
    }
  }
}
```

Example prompts:

- “Find five new remote Python jobs on We Work Remotely and summarize their timezone restrictions.”
- “Extract the latest back-end category jobs and group them by remote region.”
- “Return WWR vacancies posted this week that mention Django.”

### Reliability and Cloudflare handling

WWR currently challenges plain HTTP clients.

This Actor uses Chromium, a browser-grade user agent, bounded challenge waits, and isolated detail sessions.

Heavy resources and common analytics requests are blocked to control bandwidth and compute.

Direct access is attempted first.

Optional proxy configuration is available for environments or periods where challenges recur.

Individual enrichment failures fall back to card fields, but total enrichment failure makes the run fail visibly.

### Troubleshooting

#### Why did my run return fewer jobs than `maxItems`?

The keyword or category may contain fewer matching cards, duplicate URLs may have been removed, or the region/recency filter may exclude records.

Try removing filters and compare the visible WWR source page.

#### Why did the Actor report a Cloudflare challenge?

WWR may vary its challenge by traffic pattern or location.

Retry later with a low item limit or configure an Apify Proxy session.

Avoid high concurrency against the same source.

#### Why are some enrichment fields absent?

WWR job authors do not use a universal description template.

The Actor only emits requirements, benefits, restrictions, salary, deadlines, or skills when those values are identifiable on the public page.

#### Can I pass any website URL?

No.

Explicit URLs are restricted to relevant public We Work Remotely routes so unrelated targets cannot bypass the product scope.

### Legality and responsible use

This Actor extracts publicly visible job information without logging in.

Public availability does not remove your responsibilities.

Review WWR's terms, robots policy, database rights, privacy requirements, and the laws that apply to your use case and location.

Do not collect personal data unnecessarily, overload the source, misrepresent vacancies, or use application data for prohibited discrimination or spam.

You are responsible for your input, retention, redistribution, and downstream use.

### Data quality notes

`postedDate` is estimated from age labels such as `3d`; retain `postedText` when exact timing matters.

Description sections are extracted from employer-authored text and may not be present or consistently named.

Apply URLs can point to an employer ATS and may expire when the vacancy closes.

Source pages remain the authority; use `sourceUrl` for verification.

### Related remote job scrapers

- [Remote OK Jobs Scraper](https://apify.com/automation-lab/remote-ok-jobs-scraper) for a separate public remote-jobs feed.
- [Himalayas Remote Jobs Scraper](https://apify.com/automation-lab/himalayas-remote-jobs-scraper) for Himalayas vacancies.
- [Built In Jobs Scraper](https://apify.com/automation-lab/builtin-jobs-scraper) for Built In job listings.
- [LinkedIn Job Scraper](https://apify.com/automation-lab/linkedin-job-scraper) for broader professional-network job discovery.

Different boards are separate sources; combine them downstream when you need wider coverage.

### FAQ

#### Does the Actor require a We Work Remotely account?

No. It uses public search, category, and detail pages.

#### Does it expose private applicant information?

No. It collects public vacancy information and public application actions.

#### Can I scrape one job URL?

Yes. Add the exact WWR job URL to `startUrls` and enable full details.

#### Can I export to CSV or Excel?

Yes. Use the dataset export controls or API format parameters.

#### Are closed jobs included?

Only records reachable from the supplied public routes at run time are processed.

#### Can I run it every day?

Yes. Test a small input, save it as a task, schedule it, and deduplicate records by `sourceUrl`.

#### Does `maxItems` guarantee that many records?

No. It is an upper limit. Source availability and filters determine the actual count.

#### Is a proxy required?

Not normally. Direct browser access is the default; proxy configuration is an optional recovery tool.

# Actor input Schema

## `keyword` (type: `string`):

Find jobs matching a title, skill, company, or keyword, such as Python or product designer.

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

Scrape public weworkremotely.com search, category, all-jobs, or job-detail URLs.

## `categoryUrls` (type: `array`):

Add one or more We Work Remotely category URLs to combine category feeds.

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

Stop after saving this many unique job records.

## `includeDetails` (type: `boolean`):

Open each job page to extract descriptions, requirements, benefits, restrictions, skills, and apply links.

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

Keep jobs whose remote region or company location contains this text, such as Europe or United States.

## `recencyDays` (type: `integer`):

Keep jobs with a parseable posted age no older than this number of days.

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

Optional Apify Proxy or custom proxy settings. Start without a proxy; add one if Cloudflare challenges recur.

## Actor input object example

```json
{
  "keyword": "python",
  "startUrls": [],
  "categoryUrls": [],
  "maxItems": 5,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "keyword": "python",
    "maxItems": 5,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/we-work-remotely-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 = {
    "keyword": "python",
    "maxItems": 5,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/we-work-remotely-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 '{
  "keyword": "python",
  "maxItems": 5,
  "includeDetails": true
}' |
apify call automation-lab/we-work-remotely-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "We Work Remotely Jobs Scraper",
        "description": "🔎 Extract current We Work Remotely vacancies with full descriptions, requirements, restrictions, skills, company details, and public apply links.",
        "version": "0.1",
        "x-build-id": "1SBR4lfkSuxw15QnI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~we-work-remotely-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-we-work-remotely-jobs-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/automation-lab~we-work-remotely-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-we-work-remotely-jobs-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/automation-lab~we-work-remotely-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-we-work-remotely-jobs-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",
                "properties": {
                    "keyword": {
                        "title": "🔎 Search keyword",
                        "type": "string",
                        "description": "Find jobs matching a title, skill, company, or keyword, such as Python or product designer."
                    },
                    "startUrls": {
                        "title": "We Work Remotely start URLs",
                        "type": "array",
                        "description": "Scrape public weworkremotely.com search, category, all-jobs, or job-detail URLs.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categoryUrls": {
                        "title": "Category URLs",
                        "type": "array",
                        "description": "Add one or more We Work Remotely category URLs to combine category feeds.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after saving this many unique job records.",
                        "default": 10
                    },
                    "includeDetails": {
                        "title": "Include full job details",
                        "type": "boolean",
                        "description": "Open each job page to extract descriptions, requirements, benefits, restrictions, skills, and apply links.",
                        "default": true
                    },
                    "region": {
                        "title": "Remote region filter",
                        "type": "string",
                        "description": "Keep jobs whose remote region or company location contains this text, such as Europe or United States."
                    },
                    "recencyDays": {
                        "title": "Posted within days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Keep jobs with a parseable posted age no older than this number of days."
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings. Start without a proxy; add one if Cloudflare challenges recur.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
