# Working Nomads Jobs Scraper (`solidcode/workingnomads-scraper`) Actor

\[💰 $4 / 1K] Extract remote jobs from Working Nomads — title, company, category, tags, location, posting date, description, and apply URL. Filter across 15 categories, keywords, location, and recency.

- **URL**: https://apify.com/solidcode/workingnomads-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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/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

## Working Nomads Jobs Scraper

Pull remote job listings from Working Nomads at scale — titles, companies, categories, skill tags, locations, posting dates, USD-normalized salaries, full descriptions, and direct apply URLs for every active remote role on the board. Filter by category, keyword, location, job type, experience level, salary, and recency, all in one run. Built for job-board aggregators, recruiters sourcing remote talent, and labor-market researchers who need a clean, structured feed of remote jobs without hand-building search links or chasing a moving target.

### Why This Scraper?

- **5,000+ live remote jobs in one run** — the complete active Working Nomads catalog, not a thin sample, with the full set of fields on every record.
- **15 job categories** — Development, Management, Sales, Consulting, Marketing, System Administration, Customer Success, Finance, Design, Human Resources, Legal, Healthcare, Administration, Writing, and Education, selectable individually or in any combination.
- **USD-normalized salary intelligence** — both the raw salary range (e.g. "$178k–$331k per year") and a single comparable annual figure in US dollars, so you can sort and filter pay across currencies on the roughly half of listings that publish it.
- **3 experience levels and 3 job types as real filters** — Entry-level, Mid-level, and Senior; Full-time, Freelance / Contract, and Part-time — pulled from the source's own tagging, not guessed from job titles.
- **Minimum-salary floor filter** — set a dollar threshold and keep only roles that publish pay at or above it, ideal for high-comp sourcing.
- **"Posted within N days" recency window** — narrow to jobs posted in the last day, week, or month for daily alert pipelines and fresh-lead lists.
- **Direct apply URL on every job** — the real application link, plus the canonical Working Nomads listing URL, so candidates and recruiters skip straight to applying.
- **Clean, ready-to-use fields** — skill tags delivered as a structured list, locations as an array, descriptions stripped to readable text, and ISO 8601 posting timestamps — no markup, no manual cleanup.
- **Optional lightweight mode** — drop the full description with one toggle for a slimmer, faster feed when you only need title, company, salary, tags, and apply link.

### Use Cases

**Job-Board Aggregation**
- Populate a niche remote-jobs site with a daily refresh of the full catalog
- Mirror specific categories like Development or Design onto a vertical board
- Keep listings current by re-running with a short recency window
- De-duplicate against your existing feed using the stable job ID

**Recruitment & Sourcing**
- Build sourcing lists of Senior remote engineers paying above a salary floor
- Track which companies are hiring remotely in a given category
- Collect direct apply URLs to route candidates without manual searching
- Monitor freelance and contract openings separately from full-time roles

**Labor-Market Research**
- Measure remote-hiring volume by category over time
- Analyze published salary ranges and USD-normalized pay across roles
- Study the mix of experience levels and employment types in remote work
- Map which regions and time zones appear most often in remote postings

**Job-Alert Products**
- Power daily email or Slack alerts for new roles matching saved filters
- Trigger notifications when senior, high-salary roles appear in a category
- Feed a keyword-based alert engine across titles, companies, and descriptions
- Deliver fresh, same-day listings with a one-day recency window

**Competitive Intelligence**
- Track competitors' remote job openings and skill-tag demand
- Benchmark salary ranges your company offers against the wider market
- Watch hiring trends in specific tech stacks via skill tags
- Identify emerging tools and technologies from tag frequency

### Getting Started

#### Fetch the Latest Remote Jobs

The simplest run — no filters, just the most recent listings:

```json
{
    "maxResults": 100
}
````

#### Senior Development Roles With Published Pay

```json
{
    "categories": ["Development"],
    "experienceLevel": ["SENIOR_LEVEL"],
    "minSalaryUsd": 120000,
    "maxResults": 200
}
```

#### Keyword Search With a Recency Window

```json
{
    "searchTerms": ["python", "react"],
    "postedWithinDays": 7,
    "maxResults": 300
}
```

#### Full-Featured Example

```json
{
    "categories": ["Development", "Design"],
    "searchTerms": ["senior"],
    "location": ["Europe", "Anywhere"],
    "positionType": ["ft", "fr"],
    "experienceLevel": ["MID_LEVEL", "SENIOR_LEVEL"],
    "minSalaryUsd": 80000,
    "postedWithinDays": 30,
    "includeDescription": true,
    "maxResults": 500
}
```

### Input Reference

Every input is optional — leaving everything empty fetches the full live catalog of remote jobs.

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | string\[] | `[]` | Filter by category. Pick one or more of: Administration, Consulting, Customer Success, Development, Design, Education, Finance, Healthcare, Human Resources, Legal, Management, Marketing, Sales, System Administration, Writing. Empty includes every category. |
| `searchTerms` | string\[] | `["python"]` | Free-text keywords such as "python", "react", or "senior". A job is kept if a keyword appears in its title, company, or description. Empty skips keyword filtering. |
| `location` | string\[] | `[]` | Filter by location, region, country, or time zone text — for example "Europe", "USA", "Anywhere", or "CET". A job is kept if any of these matches its location. Empty includes all locations. |
| `positionType` | string\[] | `[]` | Employment type: Full-time, Freelance / Contract, or Part-time. Empty includes all types. |
| `experienceLevel` | string\[] | `[]` | Seniority: Entry-level, Mid-level, or Senior. Empty includes all levels. |
| `minSalaryUsd` | integer | `0` | Only include jobs whose listed annual salary is at least this amount, in US dollars. About half of jobs list a salary, so setting this excludes jobs with no published salary. `0` means no salary filter. |
| `postedWithinDays` | integer | `0` | Only include jobs posted within the last N days. `0` includes jobs of any age. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste Working Nomads category, tag, or search URLs (e.g. `https://www.workingnomads.com/remote-development-jobs`). Their filters are applied on top of the options above. Most users can leave this empty. |

#### Output & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDescription` | boolean | `true` | Include the full job description text for each result. Turn off for smaller, faster output when you only need title, company, salary, tags, location, and apply URL. |
| `maxResults` | integer | `100` | Maximum number of jobs to save. Set to `0` to return every matching job. |

### Output

Each job is one flat row. Here's a representative result:

```json
{
    "id": 1284756,
    "title": "Senior Backend Engineer",
    "company": "Acme Remote",
    "category": "Development",
    "positionType": "Full-time",
    "experienceLevel": "Senior",
    "promoted": true,
    "tags": ["python", "django", "postgresql", "aws"],
    "locations": ["Anywhere", "Europe"],
    "salaryRange": "$120k–$180k per year",
    "annualSalaryUsd": 150000,
    "publishedAt": "2026-06-18T09:30:00+00:00",
    "applyUrl": "https://acme.example.com/careers/backend-engineer",
    "url": "https://www.workingnomads.com/jobs/senior-backend-engineer-acme-remote",
    "slug": "senior-backend-engineer-acme-remote",
    "description": "We're hiring a senior backend engineer to own our core API...",
    "scrapedAt": "2026-06-19T14:30:00+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | number | Unique Working Nomads job identifier |
| `title` | string | Job title |
| `company` | string | Hiring company name |
| `category` | string | One of the 15 job categories |
| `positionType` | string | Full-time, Freelance / Contract, or Part-time |
| `experienceLevel` | string | Entry-level, Mid-level, or Senior; null if the listing doesn't specify |
| `promoted` | boolean | `true` when the listing is a featured/promoted posting on the board |
| `tags` | string\[] | Skill and technology tags |
| `description` | string | Full job description as readable text; omitted when `includeDescription` is off |

#### Location & Salary

| Field | Type | Description |
|-------|------|-------------|
| `locations` | string\[] | Location, remote region, or time-zone strings |
| `salaryRange` | string | Human-readable salary, e.g. "$120k–$180k per year"; null when not published |
| `annualSalaryUsd` | number | Salary normalized to a single annual US-dollar figure; null when not published |

#### Links & Metadata

| Field | Type | Description |
|-------|------|-------------|
| `applyUrl` | string | Direct application URL for the role |
| `url` | string | Canonical Working Nomads listing URL |
| `slug` | string | URL slug for the listing |
| `publishedAt` | string | Posting date and time (ISO 8601 with time zone) |
| `scrapedAt` | string | ISO 8601 timestamp of when the row was collected |

### Tips for Best Results

- **Start small** — set `maxResults` to 25–50 on your first run to confirm the data matches your needs, then scale up.
- **Combine `minSalaryUsd` with `experienceLevel`** — pair a salary floor with Senior to surface high-comp leadership and specialist roles in one pass; this is the fastest route to a premium sourcing list.
- **Use `postedWithinDays: 1` for daily alerts** — schedule a daily run with a one-day window so each run returns only what's new since yesterday, perfect for alert pipelines.
- **Remember the salary trade-off** — about half of listings publish pay, so any `minSalaryUsd` above 0 also drops every job with no published salary. Leave it at 0 when you want the widest catalog.
- **Turn off `includeDescription` for lean feeds** — when you only need title, company, salary, tags, and apply URL, switching it off makes the output smaller and quicker to process.
- **Select multiple categories at once** — adding several categories returns the union of all of them, so one run can cover, say, Development, Design, and Marketing together.
- **Pull the whole catalog with `maxResults: 0`** — for a full mirror, leave all filters empty and set the cap to 0; the run collects every active listing the board exposes.

### Pricing

**From $4.00 per 1,000 results** — a clean, complete remote-jobs feed that undercuts comparable scrapers. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.25 | $4.00 |
| 10,000 | $48.00 | $45.00 | $42.50 | $40.00 |
| 100,000 | $480.00 | $450.00 | $425.00 | $400.00 |

A "result" is any job row in the output dataset.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate remote-job aggregation, recruitment research, and labor-market analysis. Users are responsible for complying with applicable laws and Working Nomads' Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data in line with applicable privacy regulations.

# Actor input Schema

## `categories` (type: `array`):

Filter jobs by category. Leave empty to include every category. Pick one or more.

## `searchTerms` (type: `array`):

Free-text keywords such as 'python', 'react', or 'senior'. A job is kept if a keyword appears in its title, company, or description. Leave empty to skip keyword filtering.

## `location` (type: `array`):

Filter by location, region, country, or time zone text — for example 'Europe', 'USA', 'Anywhere', or 'CET'. A job is kept if any of these matches its location. Leave empty to include all locations.

## `positionType` (type: `array`):

Filter by employment type. Leave empty to include all types.

## `experienceLevel` (type: `array`):

Filter by seniority. Leave empty to include all experience levels.

## `minSalaryUsd` (type: `integer`):

Only include jobs whose listed annual salary is at least this amount, in US dollars. Note: about half of jobs list a salary — setting this excludes jobs with no published salary. Set to 0 for no salary filter.

## `postedWithinDays` (type: `integer`):

Only include jobs posted within the last N days. Set to 0 to include jobs of any age.

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

Advanced: paste Working Nomads category, tag, or search URLs (e.g. https://www.workingnomads.com/remote-development-jobs). Their filters are applied on top of the options above. Most users can leave this empty and just use the filters.

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

Include the full job description text for each result. Turn off for smaller, faster output when you only need title, company, salary, tags, location, and apply URL.

## `maxResults` (type: `integer`):

Maximum number of jobs to save. 0 returns every matching job; negative values fall back to the default.

## Actor input object example

```json
{
  "categories": [],
  "searchTerms": [
    "python"
  ],
  "location": [],
  "positionType": [],
  "experienceLevel": [],
  "postedWithinDays": 0,
  "startUrls": [],
  "includeDescription": true,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped remote jobs with key fields.

# 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 = {
    "categories": [],
    "searchTerms": [
        "python"
    ],
    "location": [],
    "positionType": [],
    "experienceLevel": [],
    "minSalaryUsd": 0,
    "postedWithinDays": 0,
    "startUrls": [],
    "includeDescription": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/workingnomads-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 = {
    "categories": [],
    "searchTerms": ["python"],
    "location": [],
    "positionType": [],
    "experienceLevel": [],
    "minSalaryUsd": 0,
    "postedWithinDays": 0,
    "startUrls": [],
    "includeDescription": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/workingnomads-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 '{
  "categories": [],
  "searchTerms": [
    "python"
  ],
  "location": [],
  "positionType": [],
  "experienceLevel": [],
  "minSalaryUsd": 0,
  "postedWithinDays": 0,
  "startUrls": [],
  "includeDescription": true,
  "maxResults": 100
}' |
apify call solidcode/workingnomads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Working Nomads Jobs Scraper",
        "description": "[💰 $4 / 1K] Extract remote jobs from Working Nomads — title, company, category, tags, location, posting date, description, and apply URL. Filter across 15 categories, keywords, location, and recency.",
        "version": "1.0",
        "x-build-id": "ISQrJjoBp0nuM24YH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~workingnomads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-workingnomads-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/solidcode~workingnomads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-workingnomads-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/solidcode~workingnomads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-workingnomads-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": {
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter jobs by category. Leave empty to include every category. Pick one or more.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Administration",
                                "Consulting",
                                "Customer Success",
                                "Development",
                                "Design",
                                "Education",
                                "Finance",
                                "Healthcare",
                                "Human Resources",
                                "Legal",
                                "Management",
                                "Marketing",
                                "Sales",
                                "System Administration",
                                "Writing"
                            ],
                            "enumTitles": [
                                "Administration",
                                "Consulting",
                                "Customer Success",
                                "Development",
                                "Design",
                                "Education",
                                "Finance",
                                "Healthcare",
                                "Human Resources",
                                "Legal",
                                "Management",
                                "Marketing",
                                "Sales",
                                "System Administration",
                                "Writing"
                            ]
                        }
                    },
                    "searchTerms": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Free-text keywords such as 'python', 'react', or 'senior'. A job is kept if a keyword appears in its title, company, or description. Leave empty to skip keyword filtering.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "array",
                        "description": "Filter by location, region, country, or time zone text — for example 'Europe', 'USA', 'Anywhere', or 'CET'. A job is kept if any of these matches its location. Leave empty to include all locations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "positionType": {
                        "title": "Job Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by employment type. Leave empty to include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ft",
                                "fr",
                                "pt"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Freelance / Contract",
                                "Part-time"
                            ]
                        }
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by seniority. Leave empty to include all experience levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ENTRY_LEVEL",
                                "MID_LEVEL",
                                "SENIOR_LEVEL"
                            ],
                            "enumTitles": [
                                "Entry-level",
                                "Mid-level",
                                "Senior"
                            ]
                        }
                    },
                    "minSalaryUsd": {
                        "title": "Minimum Salary (USD/year)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include jobs whose listed annual salary is at least this amount, in US dollars. Note: about half of jobs list a salary — setting this excludes jobs with no published salary. Set to 0 for no salary filter."
                    },
                    "postedWithinDays": {
                        "title": "Posted Within (days)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include jobs posted within the last N days. Set to 0 to include jobs of any age.",
                        "default": 0
                    },
                    "startUrls": {
                        "title": "Working Nomads URLs (optional)",
                        "type": "array",
                        "description": "Advanced: paste Working Nomads category, tag, or search URLs (e.g. https://www.workingnomads.com/remote-development-jobs). Their filters are applied on top of the options above. Most users can leave this empty and just use the filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDescription": {
                        "title": "Include Full Description",
                        "type": "boolean",
                        "description": "Include the full job description text for each result. Turn off for smaller, faster output when you only need title, company, salary, tags, location, and apply URL.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of jobs to save. 0 returns every matching job; negative values fall back to the default.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
