# Welcome to the Jungle Jobs Scrape Board-Wide Search + 44 Fields (`memo23/welcometothejungle-jobs-scraper`) Actor

Pull every matching Welcome to the Jungle job in one run — board-wide keyword search (US + global), or scrape specific companies, or crawl the whole board. Up to 44 fields per job incl. full description, salary, remote, experience. 13 filters at the source. No login. JSON or CSV

- **URL**: https://apify.com/memo23/welcometothejungle-jobs-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Jobs, AI, Agents
- **Stats:** 25 total users, 21 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 job listings

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Welcome to the Jungle Jobs Scraper 🌴

**Scrape jobs from [Welcome to the Jungle](https://www.welcometothejungle.com) — a board-wide keyword search across every company (US + global), or company-scoped.** Search a term like `software engineer` to pull matching jobs from the whole board, or target specific companies. Each job is one clean, flat row: full description, salary, contract, office, **remote policy**, **experience level**, key missions, benefits, plus the hiring company's profile. Pure HTTP — no login, no browser, no CAPTCHA. JSON or CSV.

![How the Welcome to the Jungle Jobs Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-welcometothejungle.png)

### Why use this scraper

- **Board-wide keyword search.** Search `software engineer`, `product manager`, etc. across **every** company on the board — **including US and global roles** — and get the matching jobs back, ranked. Most WTTJ scrapers can only fetch one company at a time.
- **Rich server-side filters.** Narrow the search by country, city, **geo-radius**, contract type, remote policy, salary, **experience range**, **company size**, sector and **occupation** — plus **title-only** matching and **sort by date** — all filtered at the source, so you only pull (and pay for) the jobs you actually want.
- **The deepest schema — 44 fields per job.** Full description, salary (min/max/currency/period), contract type, **remote policy**, **experience level**, **education level**, profession, summary, **key missions**, **benefits**, office geo, plus the company's sectors and size.
- **Resilient search — no stale-key breakage.** The board search rides the site's own engine, and this actor pulls the search credentials **fresh on every run** — so unlike scrapers that hardcode them and silently start returning zero results, ours keeps working.
- **Three ways to run.** Keyword **search** the whole board · scrape **specific companies** · or **crawl** every company.
- **Pure HTTP.** No headless browser, no CAPTCHA solver. Fast, cheap and reliable, via residential proxies.
- **Flat, spreadsheet-ready rows.** Everything denormalized onto one row. Open the CSV and filter.

### Overview

| Mode | Input | Output |
|---|---|---|
| **Search** (board-wide) | `searches: ["software engineer"]` | Jobs matching the term(s) across all companies — US + global, 44 fields |
| **Companies** | `companies: ["adlin-science-1", …]` (slug / reference / URL) | Those companies' jobs |
| **Crawl-all** | *(leave both empty)* | Every company's jobs, until `maxItems` |

### Supported input

**Search mode** — pass keyword(s) in `searches`, e.g. `["software engineer", "data scientist"]`, and pick `searchMarket` (`en` or `fr`).

**Company mode** — pass companies in `companies`, in any shape:
- Slug — `adlin-science-1`
- Company reference — `9m2XEE`
- Company URL — `https://www.welcometothejungle.com/en/companies/adlin-science-1`

Leave both empty to crawl the entire board.

### Use cases

- **Talent-market search** — pull every `software engineer` (or any role) across the whole board in one run.
- **Recruitment intelligence** — track which companies are hiring, for what, where.
- **Job-board aggregation** — pull fresh WTTJ listings (with full JDs) into your own portal or feed.
- **Labour-market analysis** — contract types, salary signals, remote policies and hiring volume by sector and country.
- **Competitive hiring research** — monitor named employers' open roles over time (company mode).

### How it works

1. **Search mode** — for each keyword the actor queries Welcome to the Jungle's own board search (credentials pulled **fresh each run**) and pages through the matches.
2. **Company mode** — each company is resolved to its WTTJ organization, then its jobs are pulled from the public jobs endpoint (full description included). Empty input = paginate every company.
3. **Emit** — jobs are de-duplicated, flattened to one row each, and pushed — all via rotating residential proxies, no browser, no CAPTCHA.

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `searches` | array | — | Board-wide keyword search terms. When set, runs in search mode (takes priority over `companies`). |
| `searchMarket` | string | `en` | Language index for search: `en` or `fr`. |
| `searchCountry` / `searchCity` | string | — | *(search mode)* Filter by office country (ISO-2, e.g. `US`, `FR`) / city (e.g. `Paris`). |
| `searchContractType` / `searchRemote` | string | — | *(search mode)* Contract type (`full_time`, `internship`…) / remote policy (`fulltime`, `partial`, `punctual`, `no`). |
| `searchSalaryMin` | integer | — | *(search mode)* Minimum yearly salary. |
| `searchExperienceMin` / `searchExperienceMax` | integer | — | *(search mode)* Experience range — min / max years required. |
| `searchSector` / `searchOccupation` | string | — | *(search mode)* Sector / job-function reference slug (e.g. `software-1`). |
| `searchCompanySizeMin` / `searchCompanySizeMax` | integer | — | *(search mode)* Hiring-company headcount range. |
| `searchInTitleOnly` | boolean | `false` | *(search mode)* Match the keyword in the job **title only** — tighter results. |
| `searchSortBy` | string | `relevance` | *(search mode)* `relevance` (default) or `date` (newest first). |
| `searchLatLng` / `searchRadiusKm` | string / integer | — | *(search mode)* Geo-radius search: centre `"lat,lng"` (e.g. `48.8566,2.3522`) + radius in km. |
| `companies` | array | — | Companies to scrape (slug / reference / URL). Used when no search terms. Empty = crawl all. |
| `keyword` | string | — | Extra client-side filter on title/description. |
| `location` | string | — | Keep only jobs whose office city / country / address contains this text. |
| `contractType` | string | — | Keep only this contract type. |
| `postedWithinDays` | integer | — | Keep only jobs published within this many days. |
| `maxItems` | integer | 200 | Max job rows per run. Free-tier capped at 100. |
| `maxConcurrency` | integer | 6 | Parallel lookups. |
| `proxy` | object | Residential | Residential rotation keeps runs stable. |

#### Example input

```json
{
  "searches": ["software engineer"],
  "searchMarket": "en",
  "maxItems": 200
}
````

### Output sample

```json
{
  "jobTitle": "Senior Software Engineer",
  "jobReference": "e6bbd04c-dc5a-4ddb-80ce-ecf4d2b8a308",
  "jobUrl": "https://www.welcometothejungle.com/en/companies/matera/jobs/cdi-senior-software-engineer",
  "description": "8+ years backend experience, ideally Ruby on Rails…",
  "companyName": "Matera",
  "companySlug": "matera",
  "companySectors": ["SaaS / Cloud Services", "Commercial Real Estate"],
  "companySize": "250",
  "contractType": "full_time",
  "remote": "partial",
  "experienceLevelMin": 7,
  "educationLevel": "bac_4",
  "profession": "Software & Web Development",
  "officeCity": "Paris",
  "officeCountry": "France",
  "salaryMin": 65000,
  "salaryMax": 85000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "yearly",
  "keyMissions": ["Architect robust solutions with Domain-Driven Design…"],
  "benefits": ["Flexible working hours", "Between 2-3 days at home", "…"],
  "publishedAt": "2026-06-26T08:37:53Z",
  "source": "search",
  "scrapedAt": "2026-06-28T06:30:00Z"
}
```

### Key output fields

| Field | Meaning |
|---|---|
| `jobTitle` / `description` | Job title and the full description. |
| `jobUrl` | Public Welcome to the Jungle job page. |
| `contractType` / `remote` | Contract type and remote policy *(remote: search mode)*. |
| `experienceLevelMin` / `educationLevel` / `profession` | Seniority, education, job function *(search mode)*. |
| `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` | Salary band where the company published it. |
| `keyMissions` / `benefits` / `summary` | Responsibilities, perks, summary *(search mode)*. |
| `officeCity` / `officeCountry` / `officeAddress` | Where the role is based. |
| `companyName` / `companySectors` / `companySize` | Hiring company profile, joined to every job. |
| `publishedAt` | ISO timestamp the job was published. |
| `source` | `search` (board-wide) or `embed` (company mode). |

### FAQ

**Do I need a Welcome to the Jungle account or API key?**
No — no login and nothing for you to supply. The actor reads public data only.

**How do I search across the whole board?**
Use `searches: ["software engineer"]` (search mode). It returns matching jobs from **every** company — including US and global roles — with the richest field set. Pick `searchMarket` (`en` / `fr`).

**Search mode vs company mode?**
Search mode pulls jobs matching your keyword(s) board-wide (best for "all X jobs everywhere"). Company mode pulls a specific company's full job list (best for monitoring named employers). Leave both empty to crawl every company.

**How many results can one search return?**
Each keyword returns up to ~1,000 jobs per run (the search engine's page cap). For larger pulls, run several narrower terms or add filters.

**Why is `salaryMin` / `salaryMax` null sometimes?**
Many companies don't publish a band; when they do, it's captured.

**How fresh is the data?**
Live — each run hits the current jobs. Use `postedWithinDays` to keep only recent postings.

### Support

Found a bug or need an extra field? Open an issue on the actor's **Issues** tab and we'll take a look.

### Explore more scrapers

- [LinkedIn Jobs Scraper](https://apify.com/memo23/linkedin-jobs-scraper) — jobs without login or cookies
- [Indeed Scraper](https://apify.com/memo23/indeed-scraper) — jobs at scale
- [Naukri Job Scraper](https://apify.com/memo23/naukri-scraper) — India + Gulf jobs
- [Glassdoor Scraper](https://apify.com/memo23/glassdoor-scraper-ppr) — employer reviews & salaries

See the [full memo23 actor catalog →](https://apify.com/memo23)

### ⚠️ Disclaimer

This actor collects only publicly available job-listing data published by Welcome to the Jungle. It does not log in, bypass authentication, or access any private or personal data. The data is intended for research, recruitment and market-analysis purposes. You are responsible for using it in compliance with Welcome to the Jungle's terms and all applicable laws.

### SEO Keywords

welcome to the jungle scraper, welcometothejungle scraper, wttj jobs scraper, welcome to the jungle job search, board-wide job search, welcome to the jungle api, welcome to the jungle jobs, software engineer jobs scraper, keyword job search api, french jobs scraper, europe jobs scraper, us jobs scraper, job board scraper, job listings scraper, welcome to the jungle company data, job description scraper, remote jobs scraper, salary data scraper, recruitment data, hiring data scraper, jobs json csv export

# Actor input Schema

## `searches` (type: `array`):

Keyword search across the whole Welcome to the Jungle board, e.g. \["software engineer", "product manager"]. Each term runs a full search; results merge and de-duplicate. Covers US + global jobs. Takes priority over Companies when set.

## `searchMarket` (type: `string`):

Language index used in search mode: English or French listings.

## `searchCountry` (type: `string`):

Office country, ISO-2 code, e.g. US, FR, GB, CA, DE, IE, NL, ES.

## `searchCity` (type: `string`):

Office city, e.g. Paris, New York, London, San Francisco.

## `searchContractType` (type: `string`):

Filter by contract type.

## `searchRemote` (type: `string`):

Filter by remote policy.

## `searchSalaryMin` (type: `integer`):

Keep only jobs whose yearly salary minimum is at or above this (in the job's own currency).

## `searchExperienceMax` (type: `integer`):

Keep only jobs requiring at most this many years of experience.

## `searchSector` (type: `string`):

Sector reference slug, e.g. software-1, artificial-intelligence-machine-learning, big-data-1, finance-2, it-digital-1.

## `searchOccupation` (type: `string`):

Job-function reference slug, e.g. software-web-development-iMzA4, data-analytics, sales. Narrower than sector.

## `searchExperienceMin` (type: `integer`):

Keep only jobs requiring at least this many years of experience. Combine with the max above for a range.

## `searchCompanySizeMin` (type: `integer`):

Keep only jobs at companies with at least this many employees.

## `searchCompanySizeMax` (type: `integer`):

Keep only jobs at companies with at most this many employees.

## `searchInTitleOnly` (type: `boolean`):

When on, the search term must appear in the job TITLE (not the description). Tighter, more precise results.

## `searchSortBy` (type: `string`):

Order results by relevance (default) or by publish date (most recent first).

## `searchLatLng` (type: `string`):

Centre point for a radius search as "lat,lng", e.g. 48.8566,2.3522 (Paris). Requires the radius below.

## `searchRadiusKm` (type: `integer`):

Radius in kilometres around the centre point above. Only jobs within this distance are kept.

## `companies` (type: `array`):

Companies to scrape, each as a Welcome to the Jungle slug (e.g. `adlin-science-1`), a company reference (e.g. `9m2XEE`), or a company URL (e.g. `https://www.welcometothejungle.com/en/companies/adlin-science-1`). Leave empty to crawl all companies.

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

Keep only jobs whose title or description contains this text (case-insensitive). Leave empty for all jobs.

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

Keep only jobs whose office city, country or address contains this text (e.g. `Paris`, `France`, `Remote`).

## `contractType` (type: `string`):

Keep only jobs of this contract type, matched against the English label (e.g. `Full-Time`, `Internship`, `Temporary`, `Apprenticeship`).

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

Keep only jobs published within this many days. Leave empty for no date limit.

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

Hard cap on job rows per run. Each kept job is one paid result. Default 200. Free-tier users are capped at 100.

## `maxConcurrency` (type: `integer`):

How many companies to fetch jobs for in parallel. 5-8 is the reliable sweet spot.

## `maxRequestRetries` (type: `integer`):

Per-request retry budget; each retry rotates onto a fresh residential proxy session.

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "searches": [
    "software engineer"
  ],
  "searchMarket": "en",
  "searchContractType": "",
  "searchRemote": "",
  "searchInTitleOnly": false,
  "searchSortBy": "relevance",
  "companies": [
    "https://www.welcometothejungle.com/en/companies/adlin-science-1"
  ],
  "maxItems": 200,
  "maxConcurrency": 6,
  "maxRequestRetries": 4
}
```

# 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 = {
    "searches": [
        "software engineer"
    ],
    "companies": [
        "https://www.welcometothejungle.com/en/companies/adlin-science-1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/welcometothejungle-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 = {
    "searches": ["software engineer"],
    "companies": ["https://www.welcometothejungle.com/en/companies/adlin-science-1"],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/welcometothejungle-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 '{
  "searches": [
    "software engineer"
  ],
  "companies": [
    "https://www.welcometothejungle.com/en/companies/adlin-science-1"
  ]
}' |
apify call memo23/welcometothejungle-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Welcome to the Jungle Jobs Scrape Board-Wide Search + 44 Fields",
        "description": "Pull every matching Welcome to the Jungle job in one run — board-wide keyword search (US + global), or scrape specific companies, or crawl the whole board. Up to 44 fields per job incl. full description, salary, remote, experience. 13 filters at the source. No login. JSON or CSV",
        "version": "0.0",
        "x-build-id": "KRD9FxrE39jWXERIf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~welcometothejungle-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-welcometothejungle-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/memo23~welcometothejungle-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-welcometothejungle-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/memo23~welcometothejungle-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-welcometothejungle-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": {
                    "searches": {
                        "title": "Search terms (board-wide keyword search)",
                        "type": "array",
                        "description": "Keyword search across the whole Welcome to the Jungle board, e.g. [\"software engineer\", \"product manager\"]. Each term runs a full search; results merge and de-duplicate. Covers US + global jobs. Takes priority over Companies when set.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchMarket": {
                        "title": "Search market / language",
                        "enum": [
                            "en",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language index used in search mode: English or French listings.",
                        "default": "en"
                    },
                    "searchCountry": {
                        "title": "Country",
                        "type": "string",
                        "description": "Office country, ISO-2 code, e.g. US, FR, GB, CA, DE, IE, NL, ES."
                    },
                    "searchCity": {
                        "title": "City",
                        "type": "string",
                        "description": "Office city, e.g. Paris, New York, London, San Francisco."
                    },
                    "searchContractType": {
                        "title": "Contract type",
                        "enum": [
                            "",
                            "full_time",
                            "internship",
                            "apprenticeship",
                            "temporary",
                            "freelance",
                            "other"
                        ],
                        "type": "string",
                        "description": "Filter by contract type.",
                        "default": ""
                    },
                    "searchRemote": {
                        "title": "Remote policy",
                        "enum": [
                            "",
                            "fulltime",
                            "partial",
                            "punctual",
                            "no"
                        ],
                        "type": "string",
                        "description": "Filter by remote policy.",
                        "default": ""
                    },
                    "searchSalaryMin": {
                        "title": "Minimum yearly salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs whose yearly salary minimum is at or above this (in the job's own currency)."
                    },
                    "searchExperienceMax": {
                        "title": "Max years of experience required",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs requiring at most this many years of experience."
                    },
                    "searchSector": {
                        "title": "Sector (reference slug)",
                        "type": "string",
                        "description": "Sector reference slug, e.g. software-1, artificial-intelligence-machine-learning, big-data-1, finance-2, it-digital-1."
                    },
                    "searchOccupation": {
                        "title": "Occupation / job function (reference slug)",
                        "type": "string",
                        "description": "Job-function reference slug, e.g. software-web-development-iMzA4, data-analytics, sales. Narrower than sector."
                    },
                    "searchExperienceMin": {
                        "title": "Min years of experience required",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs requiring at least this many years of experience. Combine with the max above for a range."
                    },
                    "searchCompanySizeMin": {
                        "title": "Min company size (employees)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs at companies with at least this many employees."
                    },
                    "searchCompanySizeMax": {
                        "title": "Max company size (employees)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs at companies with at most this many employees."
                    },
                    "searchInTitleOnly": {
                        "title": "Match keyword in job title only",
                        "type": "boolean",
                        "description": "When on, the search term must appear in the job TITLE (not the description). Tighter, more precise results.",
                        "default": false
                    },
                    "searchSortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Order results by relevance (default) or by publish date (most recent first).",
                        "default": "relevance"
                    },
                    "searchLatLng": {
                        "title": "Geo-radius centre (lat,lng)",
                        "type": "string",
                        "description": "Centre point for a radius search as \"lat,lng\", e.g. 48.8566,2.3522 (Paris). Requires the radius below."
                    },
                    "searchRadiusKm": {
                        "title": "Geo-radius (km)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Radius in kilometres around the centre point above. Only jobs within this distance are kept."
                    },
                    "companies": {
                        "title": "Companies (optional — used only when no search terms)",
                        "type": "array",
                        "description": "Companies to scrape, each as a Welcome to the Jungle slug (e.g. `adlin-science-1`), a company reference (e.g. `9m2XEE`), or a company URL (e.g. `https://www.welcometothejungle.com/en/companies/adlin-science-1`). Leave empty to crawl all companies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Keep only jobs whose title or description contains this text (case-insensitive). Leave empty for all jobs."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Keep only jobs whose office city, country or address contains this text (e.g. `Paris`, `France`, `Remote`)."
                    },
                    "contractType": {
                        "title": "Contract type",
                        "type": "string",
                        "description": "Keep only jobs of this contract type, matched against the English label (e.g. `Full-Time`, `Internship`, `Temporary`, `Apprenticeship`)."
                    },
                    "postedWithinDays": {
                        "title": "Posted within (days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Keep only jobs published within this many days. Leave empty for no date limit."
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on job rows per run. Each kept job is one paid result. Default 200. Free-tier users are capped at 100.",
                        "default": 200
                    },
                    "maxConcurrency": {
                        "title": "Max parallel company lookups",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many companies to fetch jobs for in parallel. 5-8 is the reliable sweet spot.",
                        "default": 6
                    },
                    "maxRequestRetries": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Per-request retry budget; each retry rotates onto a fresh residential proxy session.",
                        "default": 4
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```