# Welcome to the Jungle Jobs Scraper - WTTJ Job Ads API (`rel8ble/welcome-to-the-jungle-scraper`) Actor

Use this to get job ads from Welcome to the Jungle. Input: keywords, countries, cities, contract, remote, profession filters, company names or WTTJ URLs. One result = one job: title, company, size, sector, location, salary, contract, remote, date, URL; optional full description. $0.80 per 1,000.

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

## Pricing

$0.80 / 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.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Welcome to the Jungle Jobs Scraper & API - WTTJ job ads (welcometothejungle.com)

**Welcome to the Jungle Jobs Scraper** is a Welcome to the Jungle scraper and unofficial WTTJ jobs API. Give it keywords and filters (country, city, contract type, remote policy, profession, experience, salary, company size, company names) or paste welcometothejungle.com URLs, and get every matching job ad as clean JSON, CSV or Excel: title, company with headcount, sectors and logo, office location with coordinates, salary range, contract, remote policy, experience and education asked, profession, summary, key missions, candidate profile, benefits, publication date and the job URL. Turn on details to add the full description, skills, tools, recruitment process, external apply link and the company website, LinkedIn page, revenue and headquarters.

It reads the same search index the Welcome to the Jungle website uses, over plain HTTP: no browser and no login, up to 1,000 jobs per request. The site's search stops at 1,000 results per query; this scraper **splits big searches by publication date automatically**, so it is **not capped at 1,000**: in testing it returned every job on the site (90,517 of 90,517 in a cloud run, about 5 minutes at the default 1 GB memory), and all 11,599 "commercial" jobs in France in 7 seconds.

Use it for **hiring-signal lead generation** (which French, European and US startups and scale-ups are hiring for what, right now), job boards and aggregators, recruitment market mapping, salary benchmarking for France and labour-market research.

### How to use

1. Type one or more **Search keywords** (`data analyst`, `product manager`, `commercial`, `développeur`). No keyword = all jobs matching your filters.
2. Optionally filter: **Countries** (`FR`, `US`, `GB` or names), **Cities or regions** (`Paris`, `Lyon`, `London`, `Ile-de-France`), **Contract types**, **Remote policy**, **Professions**, **Company sectors**, **Experience required**, **Education required**, **Language of the job ad**, **Company size**, **Posted within (days)** and **Minimum yearly salary**.
3. Or list **Companies** by name (`Doctolib`, `Back Market`) to get all their open jobs.
4. Set **Max jobs per search** (0 = everything). Tick **Include full description & company details** if you need the ad text and the company website.
5. Click **Start**. Download the results as JSON, CSV, Excel or HTML from the **Output** tab, or pull them through the Apify API, Make, Zapier, n8n or an MCP client.

Already have links? Paste Welcome to the Jungle **search URLs** (the filters in the URL are used), **company pages** (all open jobs of that company) or **job URLs** into *Search, company or job URLs*.

### What you get

One dataset item per job ad:

- **Identity**: `id` (stable job id), `reference`, `title`, `url`, `jobSlug`.
- **Company**: `company`, `companySlug`, `companyUrl`, `companyLogoUrl`, `companyEmployees`, `companyFoundedYear`, `companySummary`, `companySectors`, `companyIndustries`, `companyLabels` (Great Place to Work, B Corp, EcoVadis...), `companyCommitments`, `companyEqualityIndex`.
- **Where**: `city`, `country`, `countryCode`, `latitude`, `longitude`, and `locations` (every office of the job).
- **Work**: `contractType` / `contractTypeLabel` (permanent, fixed-term, internship, apprenticeship, freelance...), `contractDurationMinMonths` / `Max`, `remote` / `remoteLabel` (full remote, hybrid, occasional, none), `isFullyRemote`.
- **Pay**: `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` and `salaryYearlyMin` (the site's yearly figure), as published by the employer.
- **Requirements**: `experienceYearsMin`, `educationLevel` / `educationLevelLabel`.
- **Role**: `profession` (e.g. "Back-end Developer"), `professionCategory`, `professionSubCategory`, `jobLanguage`.
- **Ad text**: `summary`, `keyMissions`, `candidateProfile`, `benefits`.
- **Dates and origin**: `publishedAt`, `isBoosted`, `sourceQuery`, `position`, `scrapedAt`.

With **Include full description & company details** on, each job also gets `description` (plain text), `recruitmentProcess`, `skills`, `tools`, `experienceLevel`, `startDate`, `applyUrl` (the company's own careers / ATS page when there is one), `officeAddresses`, `status`, `updatedAt`, and `companyWebsite`, `companyLinkedinUrl`, `companyIndustry`, `companyRevenue`, `companyAverageAge`, `companyWomenPercent`, `companyJobsCount`, `companyHeadquarters`, `companyDescription`.

### Use cases

- **Lead generation from hiring signals**: a scale-up hiring three sales reps in Paris is a prospect for sales tooling; one opening its first US office needs payroll, legal and recruiting help. Run your keywords daily with *Posted within 1 day* and push new ads to your CRM with the company website and LinkedIn page attached.
- **Recruitment agencies**: map who is hiring in your niche, company size and sector, how long ads stay up, and which companies use an external ATS (`applyUrl`).
- **Job boards and aggregators**: pull a profession, a city or the whole site into your own feed, deduplicated by `id`.
- **Salary benchmarking**: about a third of ads publish a salary range; `salaryMin` / `salaryMax` by role, city, experience and company size.
- **Labour-market research**: remote share, contract mix, internship and apprenticeship volumes in France over time.
- **AI agents**: "find hybrid product manager jobs in Paris at companies under 250 people paying at least 60k" maps straight onto the input fields.

### Input example

| Field | Default | Description |
|---|---|---|
| `searchQueries` | - | Keywords, one search each. Empty = all jobs matching the filters |
| `countries` | all | `FR`, `US`, `GB`, `CA`, `DE`, `ES` ... or English names |
| `locations` | all | Cities, regions or departments: `Paris`, `Lyon`, `London`, `Ile-de-France` |
| `contractTypes` | all | `full_time`, `part_time`, `temporary`, `internship`, `apprenticeship`, `freelance`, `vie`, `graduate_program`, `volunteer`, `idv`, `other` |
| `remote` | all | `fulltime`, `partial`, `punctual`, `no` |
| `professions` | all | 20 job families (`Tech & Engineering`) or `Category > Sub-category` |
| `sectors` | all | 20 industries (`Tech`) or `Industry > Sector` |
| `experienceLevels` | all | `0-1`, `1-3`, `3-5`, `5-10`, `10+` years |
| `educationLevels` | all | `no_diploma`, `bac`, `bac_2`, `bac_3`, `bac_5`, `phd` ... |
| `jobLanguages` | all | Language of the ad: `en`, `fr`, `de`, `es` ... |
| `companySizes` | all | `1-15`, `16-50`, `51-250`, `251-2000`, `2000+` employees |
| `companies` | - | Company names, slugs or company URLs |
| `postedWithinDays` | 0 (any) | 1 = last 24 hours, 7 = last week |
| `salaryMin` / `salaryCurrency` | 0 / any | Minimum yearly salary; `EUR`, `USD` or `GBP` |
| `language` | `en` | Output language for labels and URLs: `en`, `fr`, `es`, `cs`, `sk` |
| `sort` | `relevance` | `relevance` or `date` |
| `maxItems` | 100 | Max jobs per search; 0 = all |
| `deepSearch` | true | Split searches above 1,000 jobs so nothing is cut off |
| `includeDetails` | false | Full description, skills, recruitment process, company website (one extra request per job) |
| `startUrls` | - | Search, company or job URLs from welcometothejungle.com |
| `proxyConfiguration` | Apify datacenter | No residential proxies needed |

Hybrid or remote data jobs in Paris paying at least 50k, last 7 days, with descriptions:

```json
{
    "searchQueries": ["data engineer", "data scientist"],
    "locations": ["Paris"],
    "remote": ["partial", "fulltime"],
    "salaryMin": 50000,
    "salaryCurrency": "EUR",
    "postedWithinDays": 7,
    "maxItems": 200,
    "includeDetails": true
}
```

Every sales job in France at companies of 51 to 2,000 people, no cap:

```json
{
    "countries": ["FR"],
    "professions": ["Sales & Customer Service"],
    "companySizes": ["51-250", "251-2000"],
    "maxItems": 0
}
```

All open jobs of a few companies, and links you copied off the site:

```json
{
    "companies": ["Doctolib", "Back Market"],
    "startUrls": [
        "https://www.welcometothejungle.com/fr/jobs?query=python&refinementList%5Boffices.country_code%5D%5B%5D=FR&refinementList%5Bcontract_type%5D%5B%5D=internship",
        "https://www.welcometothejungle.com/en/companies/rte/jobs/stage-pfe-data-analyst-power-bi-f-h_paris"
    ],
    "maxItems": 0
}
```

### Output example

From a real run (search for `data engineer` in Paris, salary at least 50,000, details on; long texts and lists shortened):

```json
{
    "id": "747bb889-d72f-43a7-973d-8d44d7f3dfc4",
    "reference": "HSS_a7x2867",
    "title": "Senior Applied ML Engineer",
    "url": "https://www.welcometothejungle.com/en/companies/hiboo/jobs/senior-applied-ml-engineer_paris",
    "company": "Hiboo Systems SAS",
    "companySlug": "hiboo",
    "companyUrl": "https://www.welcometothejungle.com/en/companies/hiboo",
    "companyEmployees": 50,
    "companyFoundedYear": 2018,
    "companySummary": "Solution SaaS pour collecter et analyser les données des équipements industriels.",
    "companySectors": ["SaaS / Cloud Services"],
    "companyIndustries": ["Tech"],
    "city": "Paris",
    "country": "France",
    "countryCode": "FR",
    "latitude": 48.84464,
    "longitude": 2.38325,
    "remote": "fulltime",
    "remoteLabel": "Full remote",
    "isFullyRemote": true,
    "contractType": "full_time",
    "contractTypeLabel": "Permanent / full-time",
    "salaryMin": 63000,
    "salaryMax": 72000,
    "salaryCurrency": "EUR",
    "salaryPeriod": "year",
    "salaryYearlyMin": 63000,
    "experienceYearsMin": 5,
    "educationLevel": "bac_5",
    "educationLevelLabel": "Bac+5 (master's)",
    "profession": "Machine Learning Engineer",
    "professionCategory": "Tech & Engineering",
    "professionSubCategory": "Data / Business Intelligence",
    "jobLanguage": "fr",
    "summary": "Rejoins notre équipe en tant que Senior Applied ML Engineer. Tu seras au cœur de l'innovation, reliant la Data Science, l'ingénierie logicielle et la valeur produit livré ...",
    "keyMissions": [
        "Analyser les données brutes, extraire la valeur business et concevoir la logique de calcul ...",
        "Explorer de volumineux jeux de données, modéliser les problématiques terrain et intégrer d ..."
    ],
    "benefits": ["Flexible working hours", "Open to full remote", "Work from anywhere", "Between 1-2 days at home"],
    "publishedAt": "2026-10-07T07:38:07Z",
    "sourceQuery": "data engineer",
    "position": 5,
    "scrapedAt": "2026-10-14T17:37:02.214Z",
    "description": "En tant que Senior Applied ML Engineer, tu ne resteras pas enfermé(e) dans l’algorithmique. Tu seras la passerelle directe entre la Data Science, l’ingénierie logicielle ...",
    "recruitmentProcess": "- Échange d’introduction (30 min) 🤙 : Premier échange visio pour discuter de ton parcours, de tes attentes et de la vision d’Hiboo.
- Immersion technique & produit (45 m ...",
    "skills": ["Containerization and orchestration", "Negotiation skills"],
    "status": "published",
    "companyWebsite": "https://www.hiboo.io",
    "companyLinkedinUrl": "https://www.linkedin.com/company/hiboohq",
    "companyHeadquarters": "Paris, France"
}
```

Fill rates on a 90,518-job test run (the whole site, no details): id, title, URL, company, company logo, summary, key missions, profession, contract type, country and publication date 100%; company headcount 99%; company sectors 97%; city 93%; candidate profile 73%; coordinates 71%; company founding year 66%; experience asked 62%; remote policy 57%; benefits 48%; salary 33%; education asked 21%. On a 120-job run with details: description, company industry, headquarters and description 100%; company website 99%; skills 97%; office address 97%; company LinkedIn 81%; external apply link 70%; experience band 68%; company revenue 53%; tools 44%; recruitment process 31%. A field the employer did not fill in is `null`, never guessed.

### Pricing

Pay per result: **$0.80 per 1,000 jobs** (one result = one job ad saved to the dataset). The full description and company details are included in that price.

- 100 jobs for a quick search = $0.08
- Every "developer" job on the site, about 5,500 jobs = $4.37
- The whole site, about 90,500 jobs = $72.41
- A daily run of 20 keywords, new ads only (a few hundred jobs) = about $0.25 a day

No start fee and no charge per search. Failed requests, duplicate ads, removed job URLs and empty searches are never charged. If you set a maximum cost per run, the scraper stops cleanly when it reaches it. Apify's free plan includes $5 of monthly platform credit, enough for about 6,000 jobs.

### Integrations

- **Apify API**: run the actor and fetch results over REST, or with the official **Python** (`apify-client`) and **Node.js** (`apify-client`) clients.
- **MCP for AI agents**: through the Apify MCP server (https://mcp.apify.com), Claude, ChatGPT, Cursor and other agents can call this Welcome to the Jungle jobs API directly and read the results; the input fields are described for agents.
- **Make, Zapier and n8n**: start runs and push new jobs to your CRM, Slack, Google Sheets or Airtable.
- **Webhooks**: get notified when a run finishes and process the data right away.
- **Schedules**: run daily with `postedWithinDays: 1` and deduplicate by `id` to collect only new ads.
- **Google Sheets / Excel**: export the dataset straight into a spreadsheet.

### Limits (read before large runs)

- **1,000 jobs per single search** is the site's own limit. Deep search gets around it by cutting the search into publication-date slices that each hold fewer than 1,000 jobs; every slice is counted exactly, so the run returns all of them. In testing the whole site (90,517 jobs, 617 requests, 0 failed) came back complete.
- **The site's count for big keyword searches is an estimate.** For "commercial" in France the site said about 12,227 and the exact slices held 11,599, all of which were returned. The run summary marks such counts with `siteTotalIsEstimate`.
- **Keywords match the site's spelling.** Most French ads say "développeur", not "developer"; search both if you want both. Matching uses exact spelling when there are exact matches (no fuzzy typo matches mixed in).
- **Cities must be written as the site writes them** (`Paris`, `Lyon`, `London`, `New York`). An unknown name returns 0 jobs.
- **Salary**: about a third of ads publish a range. `salaryMin` filters on the site's yearly figure in the ad's own currency, so set `salaryCurrency` when comparing.
- **Ad text is in the language it was written in** (two thirds are French). `language` only changes labels such as professions, sectors and benefits, and the URLs.
- **No personal data.** The scraper returns the public job ad and company information only; recruiter names, photos, emails and phone numbers are not collected.
- **Details cost one request per job**: about 250 jobs a minute in the cloud (300 jobs in 73 seconds) instead of thousands.
- **Very large runs are limited by CPU, not by the site.** At the default 1 GB memory a full-site run (90,000+ jobs) takes about 5 minutes; give the run more memory to make it faster at about the same cost.

### FAQ

**Is there an official Welcome to the Jungle API for job search?**
Welcome to the Jungle's APIs are for employers (posting jobs, ATS integrations), not for reading the job market. This actor is an unofficial alternative that reads the public job search.

**Does it cover jobs outside France?**
It covers every job listed on welcometothejungle.com, which includes the US (about 18,000 jobs), the UK (about 5,000) and Canada as well as France.

**How do I get only new jobs every day?**
Schedule the actor daily with `postedWithinDays: 1` and `sort: "date"`, and deduplicate on `id` in your own system.

**How do I get every job of one company?**
Put the company name in `companies` (or its company page URL in `startUrls`) and leave the keywords empty. The run log says which company each name matched.

**Why did I get fewer jobs than the site's count?**
For big keyword searches the site's count is an estimate (see Limits). Check `RUN_SUMMARY` in the key-value store: it lists each search with the site total, whether that total is an estimate, how many date slices ran and why it stopped.

**Is scraping Welcome to the Jungle legal?**
The actor collects publicly visible job ads and company pages, not personal data. You are responsible for how you use the data and for following the site's terms and the laws that apply to you (including GDPR in the EU).

**Something is wrong or a field is missing.**
Open an issue on the Issues tab of the actor page with the run ID. It reaches the developer directly.

# Actor input Schema

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

Optional. Job keywords as typed into the Welcome to the Jungle search box, one per line: "data analyst", "product manager", "commercial", "python". Matches job titles, summaries and company names. Each keyword is one search and returns up to maxItems jobs. Leave empty to list all jobs matching the filters below. Give at least one of searchQueries, a filter, companies or startUrls.

## `countries` (type: `array`):

Optional. Countries of the job office, one per line, as two-letter codes ("FR", "US", "GB", "CA", "DE", "ES") or English names ("France", "United Kingdom"). Several = jobs in any of them. Empty = every country (about two thirds of all jobs are in France).

## `locations` (type: `array`):

Optional. Cities, regions or departments as the site writes them, one per line: "Paris", "Lyon", "London", "New York", "Ile-de-France", "Hauts-de-Seine". Matching is exact on the name (case does not matter), several = jobs in any of them. A name the site does not use returns 0 jobs.

## `contractTypes` (type: `array`):

Optional. Keep only these contract types: any of "full_time", "part_time", "temporary", "internship", "apprenticeship", "freelance", "vie", "graduate_program", "volunteer", "idv", "other". "full_time" is a permanent contract (CDI), "temporary" a fixed-term one (CDD). Empty = all.

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

Optional. Keep only these remote policies: any of "fulltime" (full remote), "partial" (hybrid), "punctual" (occasional remote), "no" (on-site). Use \["fulltime"] for fully remote jobs. Empty = all, including the many ads that do not say.

## `professions` (type: `array`):

Optional. Job families, one per line, by English name. One of the 20 categories: "Agriculture & Agri-food", "Business & Finance", "Communication & Marketing & Advertising", "Construction", "Consulting & Strategy", "Craftsmanship and manual labor", "Culture & Arts", "Education", "Fashion", "Healthcare", "Hospitality", "HR / People", "Legal", "Maintenance & Repair", "Project / Product Management", "Research & Development", "Sales & Customer Service", "Security & Defense", "Tech & Engineering", "Transport & Logistics"; or a sub-category as "Category > Sub-category", e.g. "Tech & Engineering > Software & Web Development", "Business & Finance > Accounting". Several = any of them. Empty = all.

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

Optional. Industry of the hiring company, one per line, by English name. One of the 20 industries: "Advertising / Marketing / Agency", "Architecture", "Banking / Insurance / Finance", "Consulting / Audit", "Corporate Services", "Culture / Media / Entertainment", "Distribution", "Education / Training / Recruitment", "Engineering", "Fashion / Luxury / Beauty / Lifestyle", "Food and Beverage", "Health / Social / Environment", "Hotel / Tourism / Leisure", "Industry", "Legal / Law", "Mobility / Transport", "Nonprofit / Association", "Public Administration", "Real Estate", "Tech"; or a sector as "Industry > Sector", e.g. "Tech > SaaS / Cloud Services". Several = any of them. Empty = all.

## `experienceLevels` (type: `array`):

Optional. Minimum experience the ad asks for, in years: any of "0-1", "1-3", "3-5", "5-10", "10+". Ads that do not state any experience (about half) are left out when this is set. Empty = all.

## `educationLevels` (type: `array`):

Optional. Education level the ad asks for (French scale: bac_3 = bachelor, bac_5 = master): any of "no_diploma", "cap", "bep", "bac", "bac_1", "bac_2", "bac_3", "bac_4", "bac_5", "phd". Ads without a stated level are left out when this is set. Empty = all.

## `jobLanguages` (type: `array`):

Optional. Two-letter language codes of the ad text, one per line: "en", "fr", "de", "es", "it", "pt", "nl". Use \["en"] for English-language ads only. Empty = all.

## `companySizes` (type: `array`):

Optional. Headcount of the hiring company: any of "1-15", "16-50", "51-250", "251-2000", "2000+". Empty = all.

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

Optional. Only jobs at these companies, one per line: a company name ("Doctolib", "Back Market"), its slug on the site ("back-market") or its company page URL. Names are looked up on the site; the run log shows which company each name matched. With no keywords, returns every open job of these companies.

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

Optional. Only jobs published in the last N days, integer >= 0: 1 = the last 24 hours, 7 = last week. 0 (default) = any date. Use 1 on a daily schedule to collect only new jobs.

## `salaryMin` (type: `integer`):

Optional. Lowest yearly salary to include, as a plain number in the currency of the ad (e.g. 50000). Uses the yearly minimum the site computes from the published range, so ads without a salary (about two thirds) are left out when this is set. Combine with salaryCurrency to compare like with like. 0 (default) = no minimum.

## `salaryCurrency` (type: `string`):

Optional. Keep only ads whose salary is in this currency: "EUR", "USD" or "GBP". Empty (default) = any currency, including ads without a salary.

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

Optional. Language of the site version to read: sets the language of profession names, sectors, benefits and skills, and of the job and company URLs. The ad text itself stays in the language it was written in. Default "en".

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

Optional. "relevance" (default) or "date" (newest first). With maxItems below the number of matches this decides which jobs you get.

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

Optional. Maximum jobs saved per search (one keyword, or one start URL), integer >= 0. Default 100; 0 = every job the search has. You pay per job saved ($0.0008 each), so 100 jobs = $0.08. Use 10-20 for a quick answer.

## `deepSearch` (type: `boolean`):

Optional boolean, default true. The site returns at most 1,000 jobs for any one search. With deep search on, a bigger search is split automatically by publication date into slices of under 1,000 and the results are merged without duplicates, so "developer" in France or every job on the site can be scraped in full. Only kicks in when maxItems is above 1,000 (or 0). It costs extra requests, not extra money per job.

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

Optional boolean. false (default) = search data only: title, company, size, sectors, location with coordinates, salary, contract, remote policy, experience, education, profession, summary, key missions, candidate profile, benefits, date, links; up to 1,000 jobs per request. true = also open each job to add the full description, recruitment process, skills, tools, office address, external apply link and company website, LinkedIn page, industry, revenue, headquarters and description. One extra request per job, same price per result.

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

Optional. URLs copied from welcometothejungle.com, one per line. A search URL ("https://www.welcometothejungle.com/en/jobs?query=python\&refinementList\[offices.country_code]\[]=FR") is scraped with the filters in the URL (the filter fields above are not applied to it). A company URL ("https://www.welcometothejungle.com/en/companies/doctolib") returns all open jobs of that company. A job URL (".../companies/<company>/jobs/<job>") is looked up directly and always includes the full details. A job that has been removed is listed in the run summary and is not charged.

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

Optional, advanced. Number of parallel requests, integer 1-30. Default 10. Leave unset.

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

Optional, advanced. Retries per failed or blocked request, integer 0-20; each retry uses a new session and IP (and the next search server). Default 6. Leave unset.

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

Optional, advanced. Apify Proxy settings object. Default {"useApifyProxy": true} (datacenter proxies are enough). Searches go straight to the site search service (faster); the proxy is used for job details and for searches that fail twice. Leave unset.

## Actor input object example

```json
{
  "searchQueries": [
    "data analyst"
  ],
  "postedWithinDays": 0,
  "salaryMin": 0,
  "salaryCurrency": "",
  "language": "en",
  "sort": "relevance",
  "maxItems": 20,
  "deepSearch": true,
  "includeDetails": false,
  "maxConcurrency": 10,
  "maxRequestRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All jobs found: title, company with size, sectors and logo, locations with coordinates, salary range, contract type, remote policy, experience and education asked, profession, summary, key missions, candidate profile, benefits, publication date and URLs (plus full description, skills, recruitment process and company website / LinkedIn when details are on).

## `summary` (type: `string`):

Per-search counts, the totals the site reported, how many date slices deep search ran, stop reasons and the list of anything that failed.

# 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": [
        "data analyst"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rel8ble/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": ["data analyst"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rel8ble/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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "data analyst"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rel8ble/welcome-to-the-jungle-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rel8ble/welcome-to-the-jungle-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/envwCUKhq0pmMJkBU/builds/32t5jPZcy9z1ZvfDW/openapi.json