# Welcome to the Jungle Universal Scraper (`scrapifier/welcome-to-the-jungle-scraper`) Actor

⚡ Scrape unlimited jobs from Welcome to the Jungle! Search by keywords, filter by city, contract, remote policy, experience, salary, sector or company, and instantly get rich, structured job data with the hiring company profile — for job boards, sourcing, market research or lead generation.

- **URL**: https://apify.com/scrapifier/welcome-to-the-jungle-scraper.md
- **Developed by:** [Scrapifier](https://apify.com/scrapifier) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## 🌴 Welcome to the Jungle Universal Scraper

Scrape **jobs from Welcome to the Jungle** — by rich filters **or** by pasting a URL. No login. Search by keywords, location + radius, contract, remote, experience, salary, company size, sector or company, optionally fetch full job details (apply URL, skills), and export structured data as JSON, CSV or Excel.

**Perfect for** job boards & aggregators, recruitment sourcing, salary/market research and lead generation.

### 📋 Contents

- [Overview](#-overview)
- [How to use](#-how-to-use)
- [Input](#-input)
- [Examples](#-examples)
- [Output](#-output)
- [FAQ](#-faq)
- [Support](#-support)

### 📖 Overview

Point the Actor at a search and it collects every matching job with the full detail: title, description, contract type, required experience and education, remote policy, advertised salary, sectors, precise office location (with GPS) and the **hiring company profile** (name, size, sectors, logo, description) on every row.

- **Two ways to scrape** — build a search with the filters, or paste a Welcome to the Jungle **jobs-search URL** (its filters are kept) or **company URL** (all of its jobs).
- **Powerful filters** — keywords (optionally title-only), **location + radius**, exact cities, country, contract, remote, experience (min & max), education, min salary, **company size**, sector, language, company, published date. All applied server-side.
- **Full job details (optional)** — apply URL, required skills, summary, start date and recruitment process.
- **Deep scrape** — the search returns up to 1000 jobs per query; one toggle sweeps each contract type to collect far more.
- **Company profile on every job** — name, size, sectors, logo, description. Optional flat CSV columns.
- Exports to JSON, CSV, Excel, or the Apify dataset API. No login, no proxy needed.

### 🚀 How to use

1. Type your **keywords** (or leave empty for all jobs).
2. Add **filters**: city, contract, remote, experience, salary… anything you need.
3. Set **Max results** (`0` = as many as possible; enable **Deep scrape** to exceed 1000).
4. Start the run and download your data from the **Storage** tab or the API.

### 📥 Input

| Field | Key | Type | Description |
|---|---|---|---|
| URLs | `urls` | array | Paste WTTJ **jobs-search URLs** (filters kept) or **company URLs** (all their jobs). Empty = use the filters. |
| Keywords | `query` | string | Free-text over title + description. Empty = all jobs. |
| Search in title only | `search_in_title_only` | boolean | Match keywords against the job title only. |
| Location | `location` | string | Place to search around (city / region / country), geocoded automatically. |
| Radius (km) | `radius_km` | integer | Search radius around the location. |
| Exact cities | `cities` | array | Exact office cities (more precise than location + radius). |
| Countries | `country_codes` | array | Office countries (FR, ES, GB…). |
| Contract type | `contract_types` | array | `FULL_TIME` (CDI), `INTERNSHIP` (Stage), `APPRENTICESHIP` (Alternance), `TEMPORARY` (CDD), `FREELANCE`, `VIE`, `OTHER`. |
| Remote policy | `remote` | array | `no`, `punctual`, `partial`, `fulltime`, `unknown`. |
| Experience (years) | `experience_min` / `experience_max` | integer | Keep jobs requiring between min and max years. |
| Education level | `education_levels` | array | `NO_DIPLOMA`, `BAC`, `BAC_1`…`BAC_5`. |
| Min yearly salary (€) | `salary_min` | integer | Only jobs advertising ≥ this gross yearly salary. |
| Company size | `company_min_employees` / `company_max_employees` | integer | Filter by the company's employee count (e.g. `250`+ / `≤50`). |
| Sectors | `sectors` | array | Category (`Tech`, `Distribution`…) or specific sector (`IT / Digital`, `FinTech / InsurTech`). |
| Job language | `languages` | array | `fr`, `en`, `es`… |
| Companies | `organizations` | array | Exact company names. |
| Published after / preset | `published_after` / `date_posted` | string | Custom date `YYYY-MM-DD`, or a preset (`1`,`3`,`7`,`14`,`30` days). |
| Sort | `sort` | string | `relevance` or `date`. |
| Label language | `website_country` | string | Language of sector/contract labels (`fr`, `en`, `es`…). |
| Max results | `max_results` | integer | `0` = as many as possible. |
| Deep scrape | `split_by_contract` | boolean | Sweep each contract type to exceed the 1000-per-query cap. |
| Include company profile | `include_company_info` | boolean | Attach the company to every job (default on). |
| Full job details | `include_full_details` | boolean | Fetch apply URL, skills, summary, start date, recruitment process. |
| Flat company columns | `flatten` | boolean | Add `company_*` columns for CSV/Excel. |

### 💡 Examples

**1 · Simplest — developer jobs** (pre-filled default)

```json
{ "query": "developer", "max_results": 100 }
````

**2 · Paste a Welcome to the Jungle search URL**

```json
{ "urls": ["https://www.welcometothejungle.com/fr/jobs?query=data&refinementList%5Bcontract_type%5D%5B%5D=full-time"], "max_results": 200 }
```

**3 · Around a location — tech jobs within 25 km of Lyon, big companies, with full details**

```json
{
  "query": "software",
  "location": "Lyon",
  "radius_km": 25,
  "company_min_employees": 250,
  "include_full_details": true,
  "max_results": 100
}
```

**4 · Junior internships, Bac+5, salary ≥ €35k**

```json
{
  "query": "data",
  "contract_types": ["INTERNSHIP"],
  "experience_max": 1,
  "education_levels": ["BAC_5"],
  "sectors": ["Tech"],
  "max_results": 200
}
```

**5 · Everything a company is hiring for**

```json
{ "urls": ["https://www.welcometothejungle.com/fr/companies/decathlon"], "max_results": 0 }
```

**6 · Deep sweep — every recent job in France**

```json
{ "country_codes": ["FR"], "split_by_contract": true, "sort": "date", "max_results": 5000 }
```

> Every example above is verified against live Welcome to the Jungle data.

### 📤 Output

Each job is one dataset item (JSON / CSV / Excel / API):

```json
{
  "id": "4192017",
  "url": "https://www.welcometothejungle.com/fr/companies/epsa-france/jobs/ingenieur-d-affaires-business-developer-h-f_lyon",
  "title": "Ingénieur d'affaires/Business Developer H/F",
  "contract_type": "FULL_TIME",
  "contract_type_label": "CDI",
  "experience_min_years": null,
  "education_level": "BAC_5",
  "remote": "unknown",
  "salary": { "currency": null, "yearly_min": null, "period": "none" },
  "office": { "city": "Lyon", "state": "Auvergne-Rhone-Alpes", "country_code": "FR" },
  "geoloc": { "lat": 45.7618, "lng": 4.8493 },
  "published_at": "2026-07-21T00:00:00.000+02:00",
  "company": { "name": "EPSA Dev", "slug": "epsa-france", "size": "Entre 250 et 2000 salariés", "sectors": ["Conseil / Audit"] }
}
```

### ❓ FAQ

**Do I need a proxy or an account?** No — the search API is public. Proxy is optional.

**How many jobs can I get?** A single search returns up to 1000 (the platform's limit). Turn on **Deep scrape** to sweep each contract type and collect several thousand.

**Can I get jobs from one company?** Yes — put its exact name in `organizations`, and set `max_results` to `0`.

**How do I find only junior roles?** Set `experience_max` to `0` or `1`, or filter `contract_types` to `INTERNSHIP` / `APPRENTICESHIP`.

**Is this legal?** The Actor collects publicly available data. Comply with Welcome to the Jungle's Terms of Service, GDPR and applicable laws.

### 💬 Support

Questions or issues? Post them in the **Issues** tab.

# Actor input Schema

## `urls` (type: `array`):

Paste one or more Welcome to the Jungle URLs — a jobs search URL (its filters are kept) or a company page URL (all of its jobs). Leave empty to use the filters below instead.

## `query` (type: `string`):

Free-text search over job title + description (e.g. "developer", "data scientist"). Empty = all jobs.

## `search_in_title_only` (type: `boolean`):

Match the keywords against the job title only, not the full description.

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

Search around a place, e.g. "Paris", "Lyon", "Île-de-France". Combine with a radius below (geocoded automatically).

## `radius_km` (type: `integer`):

Search radius around the location, in kilometres (e.g. 20). Only used with a location.

## `cities` (type: `array`):

Exact office cities to include (e.g. Paris, Barcelona). More precise than a location + radius.

## `country_codes` (type: `array`):

Office countries. Empty = all.

## `contract_types` (type: `array`):

One or more contract types. Empty = all.

## `remote` (type: `array`):

Remote-work policy. Empty = all.

## `experience_min` (type: `integer`):

Keep jobs requiring at least this many years of experience.

## `experience_max` (type: `integer`):

Keep jobs requiring at most this many years (great for junior roles).

## `education_levels` (type: `array`):

Required education level. Empty = all.

## `salary_min` (type: `integer`):

Only jobs advertising at least this gross yearly salary.

## `company_min_employees` (type: `integer`):

Only jobs at companies with at least this many employees (e.g. 250 for mid/large).

## `company_max_employees` (type: `integer`):

Only jobs at companies with at most this many employees (e.g. 50 for startups).

## `sectors` (type: `array`):

Only jobs in these sectors. Use a category (e.g. "Tech", "Distribution", "Conseil / Audit") or a specific sector (e.g. "IT / Digital", "FinTech / InsurTech", "E-commerce").

## `languages` (type: `array`):

Language the listing is written in. Empty = all.

## `organizations` (type: `array`):

Only jobs from these companies (exact names, e.g. Decathlon, Papernest).

## `published_after` (type: `string`):

Only jobs published on or after this date (YYYY-MM-DD).

## `date_posted` (type: `string`):

Convenience preset (combines with 'Published after' — the tighter wins).

## `sort` (type: `string`):

Result ordering.

## `website_country` (type: `string`):

Language for sector / contract / size labels in the output (job titles & descriptions stay in their original language).

## `max_results` (type: `integer`):

How many jobs to collect (0 = as many as possible). A single search reaches up to 1000; use 'Deep scrape' to go further.

## `split_by_contract` (type: `boolean`):

Search returns at most 1000 jobs per query; sweep each contract type to collect far more.

## `include_company_info` (type: `boolean`):

Attach the company (name, size, sectors, logo, description) to every job.

## `include_full_details` (type: `boolean`):

Fetch each job's full page: application URL, required skills, summary, start date and recruitment process. One extra request per job.

## `flatten` (type: `boolean`):

Add flat company\_name / company\_slug / company\_size columns for CSV/Excel.

## `emit_input_status` (type: `boolean`):

Add an input\_status report to the run's OUTPUT record.

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

Not required — the search API is public. Only set a proxy if you want to route traffic through it.

## Actor input object example

```json
{
  "query": "developer",
  "search_in_title_only": false,
  "date_posted": "any",
  "sort": "relevance",
  "website_country": "fr",
  "max_results": 100,
  "split_by_contract": false,
  "include_company_info": true,
  "include_full_details": false,
  "flatten": false,
  "emit_input_status": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

All jobs extracted by this run.

# 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 = {
    "query": "developer",
    "max_results": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapifier/welcome-to-the-jungle-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 = {
    "query": "developer",
    "max_results": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapifier/welcome-to-the-jungle-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 '{
  "query": "developer",
  "max_results": 100
}' |
apify call scrapifier/welcome-to-the-jungle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Welcome to the Jungle Universal Scraper",
        "description": "⚡ Scrape unlimited jobs from Welcome to the Jungle! Search by keywords, filter by city, contract, remote policy, experience, salary, sector or company, and instantly get rich, structured job data with the hiring company profile — for job boards, sourcing, market research or lead generation.",
        "version": "0.1",
        "x-build-id": "AZBd7WRzUp4WNj2bS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapifier~welcome-to-the-jungle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapifier-welcome-to-the-jungle-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/scrapifier~welcome-to-the-jungle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapifier-welcome-to-the-jungle-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/scrapifier~welcome-to-the-jungle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapifier-welcome-to-the-jungle-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": {
                    "urls": {
                        "title": "Welcome to the Jungle URLs",
                        "type": "array",
                        "description": "Paste one or more Welcome to the Jungle URLs — a jobs search URL (its filters are kept) or a company page URL (all of its jobs). Leave empty to use the filters below instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Free-text search over job title + description (e.g. \"developer\", \"data scientist\"). Empty = all jobs."
                    },
                    "search_in_title_only": {
                        "title": "Search in job title only",
                        "type": "boolean",
                        "description": "Match the keywords against the job title only, not the full description.",
                        "default": false
                    },
                    "location": {
                        "title": "Location (city / region / country)",
                        "type": "string",
                        "description": "Search around a place, e.g. \"Paris\", \"Lyon\", \"Île-de-France\". Combine with a radius below (geocoded automatically)."
                    },
                    "radius_km": {
                        "title": "Radius (km)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Search radius around the location, in kilometres (e.g. 20). Only used with a location."
                    },
                    "cities": {
                        "title": "Exact cities",
                        "type": "array",
                        "description": "Exact office cities to include (e.g. Paris, Barcelona). More precise than a location + radius.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country_codes": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Office countries. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FR",
                                "ES",
                                "GB",
                                "BE",
                                "DE",
                                "IT",
                                "PL",
                                "PT",
                                "NL",
                                "LU",
                                "CH",
                                "US",
                                "CA",
                                "CZ",
                                "SK"
                            ],
                            "enumTitles": [
                                "France",
                                "Spain",
                                "United Kingdom",
                                "Belgium",
                                "Germany",
                                "Italy",
                                "Poland",
                                "Portugal",
                                "Netherlands",
                                "Luxembourg",
                                "Switzerland",
                                "United States",
                                "Canada",
                                "Czechia",
                                "Slovakia"
                            ]
                        }
                    },
                    "contract_types": {
                        "title": "Contract type",
                        "type": "array",
                        "description": "One or more contract types. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FULL_TIME",
                                "INTERNSHIP",
                                "APPRENTICESHIP",
                                "TEMPORARY",
                                "FREELANCE",
                                "VIE",
                                "OTHER"
                            ],
                            "enumTitles": [
                                "Permanent (CDI)",
                                "Internship (Stage)",
                                "Apprenticeship (Alternance)",
                                "Fixed-term (CDD)",
                                "Freelance",
                                "VIE",
                                "Other"
                            ]
                        }
                    },
                    "remote": {
                        "title": "Remote policy",
                        "type": "array",
                        "description": "Remote-work policy. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "no",
                                "punctual",
                                "partial",
                                "fulltime",
                                "unknown"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Occasional remote",
                                "Partial / Hybrid",
                                "Full remote",
                                "Unspecified"
                            ]
                        }
                    },
                    "experience_min": {
                        "title": "Min experience (years)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep jobs requiring at least this many years of experience."
                    },
                    "experience_max": {
                        "title": "Max experience (years)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep jobs requiring at most this many years (great for junior roles)."
                    },
                    "education_levels": {
                        "title": "Education level",
                        "type": "array",
                        "description": "Required education level. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "NO_DIPLOMA",
                                "BAC",
                                "BAC_1",
                                "BAC_2",
                                "BAC_3",
                                "BAC_4",
                                "BAC_5"
                            ],
                            "enumTitles": [
                                "No diploma",
                                "Baccalaureate",
                                "Bac+1",
                                "Bac+2",
                                "Bac+3 (Bachelor)",
                                "Bac+4",
                                "Bac+5 (Master)"
                            ]
                        }
                    },
                    "salary_min": {
                        "title": "Min yearly salary (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only jobs advertising at least this gross yearly salary."
                    },
                    "company_min_employees": {
                        "title": "Min company size (employees)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only jobs at companies with at least this many employees (e.g. 250 for mid/large)."
                    },
                    "company_max_employees": {
                        "title": "Max company size (employees)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only jobs at companies with at most this many employees (e.g. 50 for startups)."
                    },
                    "sectors": {
                        "title": "Sectors",
                        "type": "array",
                        "description": "Only jobs in these sectors. Use a category (e.g. \"Tech\", \"Distribution\", \"Conseil / Audit\") or a specific sector (e.g. \"IT / Digital\", \"FinTech / InsurTech\", \"E-commerce\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "languages": {
                        "title": "Job language",
                        "type": "array",
                        "description": "Language the listing is written in. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fr",
                                "en",
                                "es",
                                "it",
                                "de",
                                "nl",
                                "pt"
                            ],
                            "enumTitles": [
                                "French",
                                "English",
                                "Spanish",
                                "Italian",
                                "German",
                                "Dutch",
                                "Portuguese"
                            ]
                        }
                    },
                    "organizations": {
                        "title": "Companies (by name)",
                        "type": "array",
                        "description": "Only jobs from these companies (exact names, e.g. Decathlon, Papernest).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "published_after": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Only jobs published on or after this date (YYYY-MM-DD)."
                    },
                    "date_posted": {
                        "title": "Date posted (preset)",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Convenience preset (combines with 'Published after' — the tighter wins).",
                        "default": "any"
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "relevance"
                    },
                    "website_country": {
                        "title": "Label language",
                        "enum": [
                            "fr",
                            "en",
                            "es",
                            "cs",
                            "sk"
                        ],
                        "type": "string",
                        "description": "Language for sector / contract / size labels in the output (job titles & descriptions stay in their original language).",
                        "default": "fr"
                    },
                    "max_results": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many jobs to collect (0 = as many as possible). A single search reaches up to 1000; use 'Deep scrape' to go further.",
                        "default": 100
                    },
                    "split_by_contract": {
                        "title": "Deep scrape (beyond 1000)",
                        "type": "boolean",
                        "description": "Search returns at most 1000 jobs per query; sweep each contract type to collect far more.",
                        "default": false
                    },
                    "include_company_info": {
                        "title": "Include company profile",
                        "type": "boolean",
                        "description": "Attach the company (name, size, sectors, logo, description) to every job.",
                        "default": true
                    },
                    "include_full_details": {
                        "title": "Include full job details (slower)",
                        "type": "boolean",
                        "description": "Fetch each job's full page: application URL, required skills, summary, start date and recruitment process. One extra request per job.",
                        "default": false
                    },
                    "flatten": {
                        "title": "Flat company columns (CSV-friendly)",
                        "type": "boolean",
                        "description": "Add flat company_name / company_slug / company_size columns for CSV/Excel.",
                        "default": false
                    },
                    "emit_input_status": {
                        "title": "Report empty searches",
                        "type": "boolean",
                        "description": "Add an input_status report to the run's OUTPUT record.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Not required — the search API is public. Only set a proxy if you want to route traffic through it."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
