# Welcome to the Jungle Scraper - Modern European Jobs (`santamaria-automations/welcome-to-the-jungle-scraper`) Actor

Extract job listings from welcometothejungle.com including job title, company, location, salary, contract type, tech stack, and full descriptions. Covers France, UK, Germany, Spain, and Czech Republic. Export data, run via API, schedule and monitor runs, or integrate with other tools.

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

## Pricing

from $1.00 / 1,000 job scraped from search results pages

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 Scraper - Modern European Jobs

Scrape Welcome to the Jungle — the modern European job board covering France, UK, Germany, Spain, and Czech Republic. Extract job titles, companies, salary ranges, contract types (CDI/CDD/freelance/internship), work modes, tech stacks, company profiles, and full job descriptions at scale.

Welcome to the Jungle is **France's #1 modern job board** and a favourite of European tech, startup, and scale-up employers. If you're looking for clean, rich job data from the Paris, Lyon, Berlin, London, Madrid, and Prague hiring scenes, this is the place.

---

### Features

- **3 input modes** — search by keywords, paste pre-filtered search URLs from the website, or scrape specific job URLs directly
- **Multi-country coverage** — France, United Kingdom, Germany, Spain, Czech Republic
- **Multi-language support** — English, French, Spanish, Czech, Slovak — job descriptions returned in your selected language
- **Rich company profiles** — company name, sector, size (employees), logo, company URL, and actual company website
- **Company social media** — Facebook, LinkedIn, Twitter/X, YouTube, Instagram links when available
- **Structured salary** — when employers publish a range: min / max / currency / period. Salary text extracted even when no structured data is available
- **Contract types** — CDI (permanent), CDD (fixed-term), internship, freelance, apprenticeship — with contract duration (e.g. "6 to 12 months")
- **Starting date** — when the employer specifies a start date, it's extracted as a separate field
- **Work modes** — remote / hybrid / onsite, with remote-only filter
- **Tech stack detection** — WTTJ is tech-friendly; stacks are detected automatically
- **Responsibilities & benefits** — extracted as structured lists
- **Full job descriptions** — multi-thousand-character descriptions with company story
- **Posted-at & expires-at** — precise ISO timestamps
- **Pay-per-result pricing** — only pay for jobs you actually receive

---

### Input

The scraper supports three input modes that can be used independently or combined:

#### Mode 1: Search Keywords (most common)

Search by keywords with optional filters. The scraper queries the WTTJ search backend directly.

```json
{
  "searchQueries": ["Software Engineer", "Data Scientist"],
  "country": "fr",
  "language": "en",
  "location": "Paris",
  "contractType": "cdi",
  "remoteOnly": false,
  "maxResultsPerQuery": 100,
  "includeJobDetails": true
}
````

#### Mode 2: Search URLs (advanced filters)

Paste one or more search URLs copied directly from the Welcome to the Jungle website. This lets you use **all filters** available on the website (company size, experience level, commitments, language, etc.) — even filters not exposed in this actor's input. Just set up your search on [welcometothejungle.com](https://www.welcometothejungle.com) and copy the URL.

```json
{
  "searchUrls": [
    "https://www.welcometothejungle.com/en/jobs?query=developer&refinementList%5Boffices.country_code%5D%5B%5D=FR&refinementList%5Bremote%5D%5B%5D=fulltime"
  ],
  "maxResultsPerQuery": 100,
  "includeJobDetails": true
}
```

#### Mode 3: Direct Job URLs (specific listings)

Scrape specific job pages by URL. Useful for monitoring specific listings, alive checks, or scraping a curated list.

```json
{
  "directUrls": [
    "https://www.welcometothejungle.com/en/companies/kactus/jobs/italian-speaker-venue-finder-business-developer_paris",
    "https://www.welcometothejungle.com/fr/companies/greenly/jobs/software-engineer-esg_paris"
  ]
}
```

#### All input fields

| Field | Type | Description |
|-------|------|-------------|
| `searchQueries` | array of strings | One or more search keywords. Each runs as a separate search. |
| `searchUrls` | array of strings | Pre-filtered search URLs copied from [welcometothejungle.com](https://www.welcometothejungle.com). |
| `directUrls` | array of strings | Direct job page URLs to scrape specific listings. |
| `country` | enum | `fr` (France), `uk`, `de`, `es`, `cz`. Defaults to `fr`. Used with keyword search. |
| `language` | enum | Display language: `en`, `fr`, `es`, `cs`, `sk`. Defaults to auto (from country). |
| `location` | string | Optional city name (e.g. "Paris", "Lyon", "London", "Berlin") |
| `category` | string | Optional profession filter (matches sub-category name) |
| `contractType` | enum | `cdi`, `cdd`, `internship`, `freelance`, `apprenticeship` |
| `remoteOnly` | boolean | Return only full-remote jobs |
| `maxResultsPerQuery` | integer | Cap per search keyword / search URL (default 100) |
| `maxResults` | integer | Total cap across all modes (0 = unlimited) |
| `maxConcurrency` | integer | Parallel detail page fetches (default 10, set 50 for max speed). Memory stays ~25 MB regardless. See [Speed & Concurrency](#speed--concurrency). |
| `includeJobDetails` | boolean | Fetch full details from each job page (default true, recommended) |
| `proxyConfiguration` | object | Apify proxy settings |

***

### Output example

```json
{
  "company_logo_url": "https://cdn-images.welcometothejungle.com/.../logo.jpg",
  "id": "22ac4cb5-69a6-4f42-9bea-045e3acdea58",
  "title": "Software Engineer (ESG)",
  "url": "https://www.welcometothejungle.com/fr/companies/greenly/jobs/software-engineer-esg_paris",
  "company": "Greenly",
  "company_url": "https://www.welcometothejungle.com/fr/companies/greenly",
  "company_size": "210 employees",
  "company_sector": "SocialTech / GreenTech",
  "location": "Paris, Ile-de-France, France",
  "city": "Paris",
  "region": "Ile-de-France",
  "country": "FR",
  "salary_min": 45000,
  "salary_max": 50000,
  "salary_currency": "EUR",
  "salary_period": "year",
  "salary_text": "EUR 45000 - 50000/year",
  "employment_type": "CDI",
  "contract_duration": null,
  "work_mode": "remote",
  "starting_date": "September 1, 2026",
  "experience_level": "mid",
  "description_snippet": "Join Greenly, a global leader in carbon accounting, as a Software Engineer...",
  "description_full": "About us\nGreenly was founded in 2019...\n\nYour mission...\n\nWhat we offer...",
  "requirements": ["3+ years Python or Node.js", "Experience with REST APIs"],
  "responsibilities": [
    "Contribute to efficient product delivery by ensuring the team follows best practices...",
    "Participate in product improvement by understanding user needs..."
  ],
  "company_benefits": [
    "Flexible working hours",
    "Open to full remote",
    "Reduction of working time (RTT)",
    "Team building",
    "Mental health benefits"
  ],
  "tech_stack": ["React", "Typescript"],
  "posted_at": "2026-04-09T13:58:54Z",
  "expires_at": "2026-07-08T13:58:54Z",
  "apply_url": "https://www.welcometothejungle.com/fr/companies/greenly/jobs/software-engineer-esg_paris?apply=1",
  "contact_email": null,
  "company_website": "https://www.greenly.earth",
  "facebook_url": "https://www.facebook.com/greenly.earth",
  "linkedin_url": "https://www.linkedin.com/company/greenly-earth",
  "twitter_url": "https://www.twitter.com/greenly_earth",
  "youtube_url": null,
  "instagram_url": "https://www.instagram.com/greenly.earth",
  "search_query": "Software Engineer",
  "source_url": "https://www.welcometothejungle.com/fr/companies/greenly/jobs/software-engineer-esg_paris",
  "source_platform": "welcometothejungle.com",
  "scraped_at": "2026-04-11T13:40:44Z"
}
```

***

### Use cases

#### European tech talent intelligence

Welcome to the Jungle is the go-to job board for European tech, startup, and scale-up companies. Build a real-time feed of open engineering roles across Paris, Berlin, London, Madrid, and Prague — the beating heart of the European tech scene.

#### Salary benchmarking

Unlike many EU job boards, Welcome to the Jungle encourages employers to publish salary ranges. Aggregate structured `salary_min` / `salary_max` / `salary_currency` / `salary_period` fields to build compensation benchmarks by role, city, and seniority.

#### Employer branding analysis

Every job comes with rich company context — size, sector, benefits, culture labels (B-Corp, Equality Index, Google Career Certificates). Perfect for employer-brand research, competitive intel, and culture comparison across startups.

#### French recruitment

If you recruit into the French market, this is essential infrastructure. WTTJ is the dominant modern job board in France — CDI, CDD, stages, and alternance all flow through it.

#### Job monitoring & alive checks

Use **Direct Job URLs** mode to periodically check whether specific listings are still active — perfect for recruitment pipelines and competitive monitoring.

#### Advanced filtering via Search URLs

Not all WTTJ filters are exposed in this actor's input (e.g. company commitments, company size ranges, language requirements). Use **Search URLs** mode to leverage the full filter set from the WTTJ website — just set your filters, copy the URL, and paste it.

***

### Speed & Concurrency

The scraper fetches multiple job detail pages **in parallel**, each through a different proxy IP, to maximize speed.

| `maxConcurrency` | ~100 jobs with details | Notes |
|-------------------|----------------------|-------|
| 10 (default) | ~50 seconds | Good balance of speed and politeness |
| 20 | ~30 seconds | |
| 50 | **~25 seconds** | Maximum speed, all jobs fetched at once |

Each worker gets its own proxy session (= unique IP), so requests are truly parallel without shared rate limiting.

Memory usage stays around **20-25 MB** regardless of concurrency — you can safely run 50 workers at the minimum 128 MB RAM. Just set `maxConcurrency` to control speed.

**Example**: scraping 1,000+ jobs fast → set `maxConcurrency: 50`.

***

### Pricing

This actor uses **pay-per-result** pricing:

| Event | Price | When |
|-------|-------|------|
| `job-start` | $0.001 | Once per run |
| `job-serp-result` | $0.001 | Per job from search listing (when `includeJobDetails` is off) |
| `job-detail-result` | $0.001 | Per job with full details fetched (replaces `job-serp-result`) |

#### Cost examples

| Scenario | Cost |
|----------|------|
| 100 jobs with `includeJobDetails: true` | **$0.10** (100 detail events + 1 start) |
| 100 jobs with `includeJobDetails: false` (SERP only) | **$0.10** (100 SERP events + 1 start) |
| 10 direct job URLs | **$0.01** (10 detail events + 1 start) |
| 1,000 jobs with full details | **$1.00** |

***

### Related Actors

- [France Travail Scraper](https://apify.com/santamaria-automations/france-travail-scraper) — French government job board (public sector + private)
- [LinkedIn Jobs Scraper](https://apify.com/santamaria-automations/linkedin-scraper) — LinkedIn job postings globally
- [Indeed Scraper](https://apify.com/santamaria-automations/indeed-scraper) — Indeed job listings worldwide
- [StepStone.de Scraper](https://apify.com/santamaria-automations/stepstone-de-scraper) — Germany's #1 job board
- [Pracuj.pl Scraper](https://apify.com/santamaria-automations/pracuj-pl-scraper) — Poland's #1 job board

# Actor input Schema

## `searchQueries` (type: `array`):

One or more search keywords (e.g. 'Software Engineer', 'Product Manager'). Each keyword runs as a separate search. Results are deduplicated across queries.

## `searchUrls` (type: `array`):

Paste one or more Welcome to the Jungle search URLs. Go to welcometothejungle.com, set up your filters (country, remote, company size, experience level, language, etc.), and copy the URL from your browser. All URL filters are automatically converted to search parameters. Can be combined with Search Keywords.

## `directUrls` (type: `array`):

Paste one or more direct job page URLs to scrape specific listings. Useful for monitoring specific jobs, alive checks, or scraping a curated list. Skips the search step entirely.

## `country` (type: `string`):

Country filter for keyword search. Not needed when using Search URLs (filters are in the URL).

## `language` (type: `string`):

Display language for job listings. 'Auto' uses the country's default language. When set, job details and descriptions are returned in the selected language.

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

Optional city name (e.g. 'Paris', 'Lyon', 'London', 'Berlin'). Leave empty to search the entire country.

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

Optional profession or sector filter (free text, matched against the sub-category name, e.g. 'Software & Web Development', 'Data', 'Marketing').

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

Filter by contract type. French labour market uses CDI (permanent), CDD (fixed-term), etc.

## `remoteOnly` (type: `boolean`):

When enabled, returns only jobs that allow full remote work.

## `maxResultsPerQuery` (type: `integer`):

Maximum results per search keyword or search URL. Each query gets up to this many results (deduplicated).

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

Total cap across all queries, search URLs, and direct URLs. Set to 0 for unlimited.

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

Number of job detail pages fetched in parallel, each through a different proxy IP. Higher = faster. Memory usage stays low (~25 MB) regardless of concurrency. Default 10, set to 50 for maximum speed.

## `includeJobDetails` (type: `boolean`):

When enabled (recommended), visits each job detail page to extract full description, requirements, benefits, starting date, company website, and social links. When disabled, only listing data is returned (faster, cheaper). Always on for Direct Job URLs.

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

Apify proxy settings for avoiding rate limits

## Actor input object example

```json
{
  "searchQueries": [
    "Software Engineer"
  ],
  "country": "fr",
  "language": "",
  "location": "Paris",
  "contractType": "",
  "remoteOnly": false,
  "maxResultsPerQuery": 50,
  "maxResults": 0,
  "maxConcurrency": 0,
  "includeJobDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `jobListings` (type: `string`):

Dataset containing scraped job listings

# 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 = {
    "searchQueries": [
        "Software Engineer"
    ],
    "maxResultsPerQuery": 50,
    "maxConcurrency": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("santamaria-automations/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 = {
    "searchQueries": ["Software Engineer"],
    "maxResultsPerQuery": 50,
    "maxConcurrency": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("santamaria-automations/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 '{
  "searchQueries": [
    "Software Engineer"
  ],
  "maxResultsPerQuery": 50,
  "maxConcurrency": 0
}' |
apify call santamaria-automations/welcome-to-the-jungle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Welcome to the Jungle Scraper - Modern European Jobs",
        "description": "Extract job listings from welcometothejungle.com including job title, company, location, salary, contract type, tech stack, and full descriptions. Covers France, UK, Germany, Spain, and Czech Republic. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "1.0",
        "x-build-id": "ZbIku5zCgmZW15zZu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/santamaria-automations~welcome-to-the-jungle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-santamaria-automations-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/santamaria-automations~welcome-to-the-jungle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-santamaria-automations-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/santamaria-automations~welcome-to-the-jungle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-santamaria-automations-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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "One or more search keywords (e.g. 'Software Engineer', 'Product Manager'). Each keyword runs as a separate search. Results are deduplicated across queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste one or more Welcome to the Jungle search URLs. Go to welcometothejungle.com, set up your filters (country, remote, company size, experience level, language, etc.), and copy the URL from your browser. All URL filters are automatically converted to search parameters. Can be combined with Search Keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "directUrls": {
                        "title": "Direct Job URLs",
                        "type": "array",
                        "description": "Paste one or more direct job page URLs to scrape specific listings. Useful for monitoring specific jobs, alive checks, or scraping a curated list. Skips the search step entirely.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "fr",
                            "uk",
                            "de",
                            "es",
                            "cz"
                        ],
                        "type": "string",
                        "description": "Country filter for keyword search. Not needed when using Search URLs (filters are in the URL).",
                        "default": "fr"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "",
                            "en",
                            "fr",
                            "es",
                            "cs",
                            "sk"
                        ],
                        "type": "string",
                        "description": "Display language for job listings. 'Auto' uses the country's default language. When set, job details and descriptions are returned in the selected language.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location (city)",
                        "type": "string",
                        "description": "Optional city name (e.g. 'Paris', 'Lyon', 'London', 'Berlin'). Leave empty to search the entire country."
                    },
                    "category": {
                        "title": "Profession / Sector",
                        "type": "string",
                        "description": "Optional profession or sector filter (free text, matched against the sub-category name, e.g. 'Software & Web Development', 'Data', 'Marketing')."
                    },
                    "contractType": {
                        "title": "Contract Type",
                        "enum": [
                            "",
                            "cdi",
                            "cdd",
                            "internship",
                            "freelance",
                            "apprenticeship"
                        ],
                        "type": "string",
                        "description": "Filter by contract type. French labour market uses CDI (permanent), CDD (fixed-term), etc.",
                        "default": ""
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "When enabled, returns only jobs that allow full remote work.",
                        "default": false
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results per Query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum results per search keyword or search URL. Each query gets up to this many results (deduplicated).",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max Total Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Total cap across all queries, search URLs, and direct URLs. Set to 0 for unlimited.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of job detail pages fetched in parallel, each through a different proxy IP. Higher = faster. Memory usage stays low (~25 MB) regardless of concurrency. Default 10, set to 50 for maximum speed.",
                        "default": 0
                    },
                    "includeJobDetails": {
                        "title": "Include Full Job Details",
                        "type": "boolean",
                        "description": "When enabled (recommended), visits each job detail page to extract full description, requirements, benefits, starting date, company website, and social links. When disabled, only listing data is returned (faster, cheaper). Always on for Direct Job URLs.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings for avoiding rate limits",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
