# Welcome to the Jungle Scraper ($0.26/1K): Jobs & Salaries (`tsutseisoftware/welcome-to-the-jungle-scraper`) Actor

Scrape Welcome to the Jungle jobs: title, company with size and labels, offices, contract, remote policy, salary per year, profession and benefits. All website filters, full descriptions with apply links, monitoring of new and closed jobs, notifications, market summary. Unofficial.

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

## Pricing

from $0.16 / 1,000 jobs

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/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 Scraper: Jobs, Salaries & Companies

Get job ads from **Welcome to the Jungle** (welcometothejungle.com, also known as WTTJ) as clean, ready-to-use data. Search by **keyword**, **country**, **city**, **distance from a place**, **contract type** (permanent, internship, apprenticeship, freelance…), **remote policy**, **job category**, **company sector and size**, **education**, **experience**, **minimum salary** and **publication date**, or paste any Welcome to the Jungle search, company or job URL. For each job you get the title, the company with its size, founding year, labels and gender equality index, every office, the contract, the remote policy, the **salary as shown and per year**, the profession, the key missions, the candidate profile and the benefits.

**$0.26 per 1 000 jobs**, $0.56 with the full description, apply link and details. No proxy setup and no extra platform costs.

Built for **recruiters, job boards, HR analysts and job seekers**: schedule it daily in monitoring mode and you get only jobs that are new or changed, plus, if you want, the jobs that **were closed**. Every run also saves a free **market summary**: yearly salary quartiles per currency by country, contract type, remote policy and job category, top companies, cities and company sizes.

### Why use this Welcome to the Jungle scraper?

- 🔎 **All the website's filters** (filtered-out jobs cost nothing): countries, cities, a GPS point with a radius, 11 contract types, remote policy, 20 job categories, 20 company sectors, company size, education, years of experience, minimum yearly salary, only jobs with a salary, posted in the last N days, language of the ad, title-only search, no promoted jobs.
- ♾️ **Every job of a large search.** The website shows at most 1 000 jobs for one search; with **Max jobs** 0 the actor reads all of them (all 2 439 "data engineer" jobs in France in 23 seconds in our test; 18 024 US jobs in 14 minutes) and checks the result against the website's own count where the website gives an exact one.
- 💰 **Salaries you can compare.** The salary as shown (from, to, currency, period) and the same as **yearly amounts**; amounts that don't fit their period are kept as shown and not converted.
- 🏢 **Company data in every row at no extra cost:** size, founding year, sectors, labels (Great Place to Work, B Corp…), commitments, gender equality index, logo and summary.
- 📝 **Description and details (optional):** the full job description in text, Markdown or HTML, the recruitment process, skills, tools, the **apply link** (the employer's own application page), the start date, the street address and more about the company (website, LinkedIn, headquarters, industry, average age, share of women).
- 📬 **Monitoring mode:** a daily feed of new and changed jobs (`changeType`, `changedFields`), optionally with **closed jobs** (`expired` or `noLongerMatches`, with `daysOnline`).
- 🔔 **Job alerts without any integration:** send the saved jobs to **Slack, Discord, Telegram, WhatsApp** or your own **webhook** (Zapier, Make, n8n) after each run.
- 🌍 **Labels in five languages:** categories, professions, sectors and skills in English, French, Spanish, Czech or Slovak.
- 🔒 **Privacy first.** No recruiter or employee names or contacts: e-mails and phone numbers inside texts are always removed.

#### How it compares with other Welcome to the Jungle scrapers

An honest comparison with the Welcome to the Jungle scrapers most used in the Store (checked 2026-11-15), without naming them:

| Capability | This actor | Other scrapers |
|---|---|---|
| Keyword, country, city, radius, contract, remote, salary, experience and company filters, URLs | yes | yes |
| Every job of a large search (past the 1 000 the website shows) | yes | some |
| Full description, apply link, skills, recruitment process | yes (option) | yes (option or always) |
| Monitoring of new and changed jobs | yes | some |
| Closed jobs reported (`expired` or `noLongerMatches`) | yes | no |
| Notifications to Slack, Discord, Telegram, WhatsApp or a webhook | yes | one of four |
| Market summary of every run | yes | no |
| Price per 1 000 jobs (Free plan) | $0.26, $0.56 with details | $0.30 to $2.99 |

### What data can you get?

| Group | Fields |
|---|---|
| Job | `title`, `url`, `contractType`, `contractDurationMinMonths`, `contractDurationMaxMonths`, `remote`, `educationLevel`, `experienceMinYears`, `category`, `subcategory`, `profession`, `language`, `summary`, `keyMissions`, `candidateProfile`, `benefits`, `isPromoted`, `postedAt` |
| Salary | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryYearlyMin`, `salaryYearlyMax` |
| Place | `location`, `city`, `region`, `country`, `countryCode`, `locations` (every office), `latitude`, `longitude` |
| Company | `company`, `companySlug`, `companyUrl`, `companyLogoUrl`, `companySummary`, `companyEmployees`, `companyFoundedYear`, `companyEqualityIndex`, `companyLabels`, `companyCommitments`, `sectors` |
| Details (option) | `description`, `recruitmentProcess`, `companyDescription`, `skills`, `tools`, `applyUrl`, `applyOnWebsite`, `startDate`, `address`, `postalCode`, `updatedAt`, `companyWebsite`, `companyLinkedIn`, `companyHeadquarters`, `companyIndustry`, `companyAverageAge`, `companyWomenPercent` |
| Monitoring | `changeType`, `changedFields`, `firstSeenAt`, `removedAt`, `removedReason`, `daysOnline` |

How full the fields are (measured 2026-11-15 on 6 733 jobs for "python", mostly in the US, France and the UK): salary 56 % (about 30 % of all jobs on the website show one), key missions and summary 100 %, candidate profile 96 %, experience 88 %, company size 99 %. With details: description 100 %, apply link 98 %, skills 98 %, tools 82 %, street address about 25 % (French jobs mostly have one).

### How to scrape Welcome to the Jungle

1. Open the actor and enter one or more **Search queries** (e.g. `data engineer`), or list **Companies**, or paste **Welcome to the Jungle URLs** (a company page or a job page).
2. Narrow it with the **Filters**: countries (`FR`, `GB`, `US`…), cities, contract types, remote work, categories, salary…
3. Set **Max jobs** (0 = every job of the search) and turn on **Add description and details** if you need the full ad and the apply link.
4. Click **Start** and download the dataset as **JSON, CSV, Excel, XML or HTML**, or read it through the Apify API.
5. To watch a search, turn on **Monitoring: only new or changed jobs** and schedule the actor daily.

### Use cases

#### Python jobs in Paris with a salary

```json
{
  "searchQueries": ["python developer"],
  "cities": ["Paris"],
  "onlyWithSalary": true,
  "maxItems": 100
}
```

#### Every internship in France posted this week, with the full ads

```json
{
  "countries": ["FR"],
  "contractTypes": ["internship"],
  "postedWithinDays": 7,
  "includeDetails": true,
  "maxItems": 0
}
```

#### New remote tech jobs every morning, with closed ones, to Slack

```json
{
  "categories": ["tech-engineering-3NjUy"],
  "remote": ["fulltime"],
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "remote-tech",
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxItems": 0
}
```

#### All jobs of a few companies, labels in French

```json
{
  "companies": ["doctolib", "decathlon", "https://www.welcometothejungle.com/fr/companies/thales"],
  "siteLanguage": "fr",
  "maxItems": 0
}
```

#### Data jobs at small companies near Lyon, juniors welcome

```json
{
  "searchQueries": ["data"],
  "nearLocation": "45.764, 4.8357",
  "radiusKm": 30,
  "companySizes": ["1-15", "16-50", "51-250"],
  "maxExperienceYears": 2,
  "maxItems": 200
}
```

#### A company or a job from the website

Paste a company page (all its jobs) or a job page into **Welcome to the Jungle URLs**; job URLs are saved with all their details (when the website rejects a job's page, the job is found in the website's search and saved with its listing data, without the details charge). Older job search URLs of the website (…/jobs?query=…) work too.

```json
{
  "startUrls": [
    { "url": "https://www.welcometothejungle.com/en/companies/doctolib" },
    { "url": "https://www.welcometothejungle.com/en/companies/mooncard/jobs/fullstack-data-engineer_paris_MOONC_1VGz4b6" }
  ],
  "maxItems": 100
}
```

#### Monitoring mode

The actor remembers the jobs of earlier runs with the same **Monitoring: key** and saves only jobs that are new or whose title, company, places, remote policy, contract or salary changed. Unchanged jobs are not saved and not charged; every search answer read in this mode (up to 500 jobs) is a small "Monitoring page" charge. With **Monitoring: include removed jobs**, jobs of earlier runs that are no longer in the results come as rows with `changeType: "removed"` and `removedReason` `expired` (the job was closed) or `noLongerMatches` (still published, no longer matching the search). They are checked only when every search of the run was read to its end.

#### Market summary (SUMMARY)

Every run saves a free summary to the key-value store (record `SUMMARY`): jobs matched, share with a salary, yearly salary quartiles per currency (overall, by country, contract type, remote policy and job category), top companies, countries, cities, categories, contract types, remote policy and company sizes.

### How much does it cost to scrape Welcome to the Jungle?

Pay per event; the prices are also on the **Pricing** tab.

| Event | Price | When |
|---|---|---|
| Job saved in the dataset | **$0.26 / 1 000** (Bronze, Silver, Gold and higher $0.16) | every saved row |
| Job details | + $0.30 / 1 000 | a job saved with **Add description and details**, or given by its job URL |
| Actor start | $0.003 per run | once per run |
| Monitoring page | $1.00 / 1 000 answers | monitoring mode: every search answer read (up to 500 jobs), so unchanged jobs cost little |
| Extra page | $1.00 / 1 000 requests | requests beyond what the saved jobs explain: a search that finds nothing, URLs of closed jobs, second attempts. If the saved jobs don't cover a run's cost (e.g. a run that waits long because the website delays answers), the difference is charged as extra pages; the log says how many. A normal run pays nothing here. |
| Notification | $0.001 per run | a run that sent its notification (all channels together) |

| Typical run | Price (Free plan) | Typical time |
|---|---|---|
| 20 jobs (the example input) | $0.008 | under 10 s |
| 1 000 jobs | $0.26 | about 10 to 30 s |
| 1 000 jobs with details | $0.56 | about 9 minutes |
| Every job for "python" (6 733 jobs) | $1.75 | about 3.5 minutes |
| Daily monitoring of a search with 2 000 jobs, 30 new | $0.015 | under 30 s |

You can set a maximum cost per run; the actor stops when it is reached. Jobs whose details could not be read are saved with their list data and not charged the details price.

### Input example

```json
{
  "searchQueries": ["python developer"],
  "countries": ["FR", "BE"],
  "remote": ["partial", "fulltime"],
  "maxItems": 50,
  "includeDetails": true,
  "descriptionFormat": "markdown"
}
```

### Output example

```json
{
  "id": "f845bc32-aace-4e62-bf73-4d7da1008ab4",
  "source": "Welcome to the Jungle",
  "url": "https://www.welcometothejungle.com/en/companies/mooncard/jobs/fullstack-data-engineer_paris_MOONC_1VGz4b6",
  "title": "Fullstack Data Engineer",
  "company": "Mooncard",
  "companySlug": "mooncard",
  "companyEmployees": 74,
  "companyFoundedYear": 2016,
  "companyEqualityIndex": 45,
  "location": "Paris, France",
  "countryCode": "FR",
  "remote": "partial",
  "contractType": "full_time",
  "experienceMinYears": 4,
  "salaryMin": 50000,
  "salaryMax": 65000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "salaryYearlyMin": 50000,
  "salaryYearlyMax": 65000,
  "category": "Tech & Engineering",
  "subcategory": "Data / Business Intelligence",
  "profession": "Data Engineer",
  "sectors": ["Banking", "IT / Digital", "Big Data"],
  "language": "fr",
  "summary": "Rejoignez Mooncard, une Fintech française innovante qui révolutionne les dépenses professionnelles…",
  "keyMissions": ["Construire et maintenir des pipelines de données robustes…"],
  "benefits": ["Between 2-3 days at home", "Cooptation bonus"],
  "isPromoted": false,
  "postedAt": "2026-11-13T13:38:49Z",
  "description": "Mooncard est la Fintech française qui révolutionne les dépenses professionnelles…",
  "skills": ["Data privacy", "Teamwork", "Data visualization"],
  "tools": ["Git", "Looker", "Snowflake", "DBT"],
  "applyUrl": "https://careers.mooncard.co/jobs/8725022-fullstack-data-engineer/applications/new",
  "applyOnWebsite": false,
  "startDate": "2026-11-30T23:00:00Z",
  "address": "4 Rue Jules Lefebvre, 75009 Paris, France",
  "postalCode": "75009",
  "companyWebsite": "https://www.mooncard.co/",
  "companyLinkedIn": "https://www.linkedin.com/company/mooncard",
  "companyAverageAge": 32,
  "companyWomenPercent": 48,
  "detailScraped": true,
  "scrapedAt": "2026-11-15T08:03:17Z",
  "changeType": null
}
```

### Limitations

- About 30 % of the jobs on Welcome to the Jungle show a salary (more in the US, where salary ranges are common). Some employers give a yearly amount as monthly; such amounts are kept as shown and get no yearly figure.
- Job pages exist in English and French only: rows link to the English pages, or to the French ones with French labels. The ads themselves stay in the language they were written in.
- Cities are matched as the website writes them (Paris, Lyon, London, New York, Prague…). For a radius, use **Near a place** with coordinates.
- Free text may mention a person by name (e.g. "you will report to …"); e-mails and phone numbers are always removed.
- A request the website rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. The actor never solves challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/welcome-to-the-jungle-scraper").call(run_input={
    "searchQueries": ["data engineer"], "countries": ["FR"], "maxItems": 100,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["salaryYearlyMin"], job["salaryYearlyMax"], job["url"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["salary"]["byCurrency"], summary["topCompanies"][:10])
```

**Compact output** keeps the core fields (title, company, place, country, remote, contract, salary, category, date, link) plus the fields of the options you turned on: smaller rows for AI agents, MCP clients and spreadsheets.

### Troubleshooting

- **"Nothing to search"**: add a search query, a filter, a company or a Welcome to the Jungle URL.
- **"Unknown company"**: use the name from the company's page URL on Welcome to the Jungle (…/companies/<name>), e.g. `doctolib`, or paste the whole URL.
- **"Your maximum cost per run … does not cover the start of the run"**: raise the maximum cost per run in the run options.
- **"job URLs of closed jobs skipped"**: the jobs are no longer published; use the URL of an open job.
- **"no jobs: …"**: the website found nothing for the search; try fewer filters or check the city spelling.
- **"rejecting requests"**: try again later.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### More job scrapers

Jobs from another source, with salaries and monitoring:

- [StepStone Scraper](https://apify.com/tsutseisoftware/stepstone-scraper): jobs from StepStone in Germany, Austria, Belgium and the Netherlands: salary as numbers, hiring signals, monitoring
- [SEEK Scraper](https://apify.com/tsutseisoftware/seek-scraper): jobs from SEEK in Australia and New Zealand: salary as numbers, past the 550-job limit, hiring signals, removed jobs
- [XING Jobs Scraper](https://apify.com/tsutseisoftware/xing-jobs-scraper): jobs from XING in Germany, Austria and Switzerland: full description, salary as numbers, past the 1,000-job limit, removed jobs, alerts
- [Arbeitsagentur Jobbörse Scraper](https://apify.com/tsutseisoftware/arbeitsagentur-scraper): jobs from the Jobbörse of the Bundesagentur für Arbeit, Germany's largest job board: salary as numbers, employer profiles, removed jobs, alerts
- [LinkedIn Jobs Scraper](https://apify.com/tsutseisoftware/linkedin-jobs-scraper): public LinkedIn jobs in any country without login: salary as numbers, seniority, applicants, hiring signals, new and removed jobs, alerts
- [Career Site Job Search & Scraper](https://apify.com/tsutseisoftware/ats-jobs-scraper): jobs straight from company career sites on Greenhouse, Workday, Lever, Ashby and SmartRecruiters in any country, including the jobs that just closed

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

#### Is it legal to scrape Welcome to the Jungle?

It reads only publicly available data, without logging in, at most 120 requests per minute, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. It returns no names or contacts of recruiters or employees and removes e-mails and phone numbers from the texts. The website's terms of use may restrict extracting its data; you are responsible for how you use the data (GDPR, database rights and the website's terms). If in doubt, consult a lawyer. This actor is not affiliated with Welcome to the Jungle.

#### Which countries does it cover?

Every country with jobs on Welcome to the Jungle: mostly France, the US and the UK, then Canada, Germany, Spain, Ireland, the Netherlands, Belgium and others, including a few jobs in the Czech Republic and Slovakia. Use **Countries** with two-letter codes.

#### Why is the salary empty for many jobs?

Most employers on Welcome to the Jungle don't publish a salary. **Only jobs with a salary** keeps the ones that do.

#### Do I need a proxy?

No. Nothing to set up, and the platform costs are included in the price.

#### Can I use it from an AI agent or through MCP?

Yes. Use **Compact output** for smaller rows, and call the actor through the Apify API or Apify's MCP server.

Also known as a Welcome to the Jungle API, WTTJ scraper, WTTJ jobs export or "offres d'emploi Welcome to the Jungle".

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/welcome-to-the-jungle-scraper/changelog.md

# Actor input Schema

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

Job titles or keywords, e.g. "python developer", "data analyst", "product manager", "chargé de clientèle". Each query is a separate search, combined with the filters below. Empty with filters = all jobs that match the filters.

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

Paste URLs from welcometothejungle.com: a company page (all its jobs, e.g. https://www.welcometothejungle.com/en/companies/doctolib) or a job page (https://www.welcometothejungle.com/en/companies/<company>/jobs/<job>, saved with its full details). Older job search URLs of the website (…/jobs?query=data%20engineer) work too. The filters below apply to the companies and searches as well.

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

All jobs of these companies: the name from the company's page URL (…/companies/<name>), e.g. "doctolib", "decathlon", "thales", or the whole URL.

## `siteLanguage` (type: `string`):

Language of categories, professions, sectors and skills in the output (the job ads stay in the language they were written in). Job URLs lead to the English pages, or the French ones with French labels.

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

Maximum number of jobs saved. You pay per saved job. 0 = no limit (every job of the searches, also past the 1 000 jobs the website shows for one search).

## `maxItemsPerSearch` (type: `integer`):

Limit for each search, company and URL separately, so one large search doesn't use up the whole Max jobs. 0 = no limit.

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

Adds the full job description (e-mails and phone numbers removed), the recruitment process, skills and tools, the apply link, the start date, the street address and postcode, and more about the company (website, LinkedIn, headquarters, industry, average age, share of women). Extra charge "Job details": $0.30 per 1 000 jobs with details (from 2026-11-15). Without it, every job still has the summary, key missions, candidate profile, benefits, salary, contract, remote policy and company data at no extra cost.

## `descriptionFormat` (type: `string`):

Format of the description, the candidate profile and the recruitment process: plain text, simple HTML or Markdown (good for AI agents and Notion).

## `descriptionMaxLength` (type: `integer`):

Shorten the description, candidate profile and company description to about this many characters (e.g. 300 for a snippet). 0 = full text.

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

Two-letter codes of the countries of the job's office, e.g. FR, GB, US, ES, DE, BE, NL, CZ, SK (several = any of them).

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

Cities of the job's office as the website writes them, e.g. "Paris", "Lyon", "London", "New York", "Prague" (several = any of them).

## `nearLocation` (type: `string`):

Only jobs within "Radius" of this point, e.g. "48.8566, 2.3522" for Paris. Copy the numbers from a map.

## `radiusKm` (type: `integer`):

With "Near a place": the distance from the point.

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

Only these contract types (several = any of them).

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

Only jobs with this remote policy (several = any of them).

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

Only jobs of these professions (several = any of them).

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

Only jobs of companies in these sectors (several = any of them).

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

Only companies of this size (several = any of them).

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

Only jobs asking for this level of education (French levels; several = any of them). Most jobs don't state one, so this filter keeps few jobs.

## `maxExperienceYears` (type: `integer`):

Only jobs that ask for at most this many years of experience, e.g. 0 or 1 for juniors and graduates. Empty = any.

## `minYearlySalary` (type: `integer`):

Only jobs whose salary per year starts at this amount or more (in the currency of the ad), e.g. 50000. Jobs without a salary are skipped.

## `onlyWithSalary` (type: `boolean`):

Skip jobs that show no salary (about two thirds of all jobs show none).

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

Only jobs published in the last N days, e.g. 1 for a daily feed. 0 = any time.

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

Only ads written in these languages: two-letter codes, e.g. en, fr, de, es.

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

Match the search queries in the job title only (fewer, more precise results).

## `excludePromoted` (type: `boolean`):

Skip jobs the employer paid to promote.

## `sortBy` (type: `string`):

Order of the results (matters with Max jobs). Companies are read newest first. Past the 1 000 jobs the website shows for one search, the rest comes newest first.

## `onlyNewOrChanged` (type: `boolean`):

Return only jobs that are new or whose title, company, places, remote policy, contract or salary changed since the previous run with the same Monitoring key. Unchanged jobs are free; every search answer read in this mode (up to 500 jobs each) is the "Monitoring page" event ($1.00 per 1 000 answers, from 2026-11-15).

## `monitoringKey` (type: `string`):

Name of the saved state. Use a different key for each watched search (e.g. "python-paris"). Empty = "default". The value is stored encrypted.

## `includeRemovedJobs` (type: `boolean`):

With "Monitoring: only new or changed jobs": also return jobs of earlier runs that are no longer in the results, as rows with changeType "removed" and removedReason "expired" (the job was closed) or "noLongerMatches" (still published but no longer matching the search), with daysOnline. Checked only when every search was read to its end; a removed job is a saved row.

## `telegramBotToken` (type: `string`):

After each run, send the saved jobs (in monitoring mode only the new, changed and removed ones) to Telegram, Slack, Discord, WhatsApp or your webhook: title, company, place, salary and link. A run that sent its notification is the "Notification" event ($0.001 per run, from 2026-11-15). Token of your bot from @BotFather.

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n…): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many jobs are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no job (e.g. a monitoring run without new jobs).

## `compactOutput` (type: `boolean`):

Only the core fields (title, company, place, country, remote, contract, salary, category, date, URL) plus the fields of the options you turned on. Smaller rows for AI agents, MCP clients and spreadsheets.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searchQueries": [
    "python developer"
  ],
  "siteLanguage": "en",
  "maxItems": 20,
  "maxItemsPerSearch": 0,
  "includeDetails": false,
  "descriptionFormat": "text",
  "descriptionMaxLength": 0,
  "radiusKm": 20,
  "onlyWithSalary": false,
  "searchInTitleOnly": false,
  "excludePromoted": false,
  "sortBy": "relevance",
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "compactOutput": false,
  "sendErrorReports": true
}
```

# Actor output Schema

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

The saved jobs (one row per job), in the run's default dataset.

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

Free summary of the jobs the run found: yearly salary quartiles per currency (by country, contract type, remote policy and job category), top companies, countries, cities, categories, contract types, remote policy and company sizes.

# 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": [
        "python developer"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/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": ["python developer"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/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": [
    "python developer"
  ],
  "maxItems": 20
}' |
apify call tsutseisoftware/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,tsutseisoftware/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/go84h9HlF9z9pr5fP/builds/tfbAHbfKCVhMBNQ1O/openapi.json
