# Welcome to the Jungle Jobs Scraper (`datahamster/welcome-to-the-jungle-jobs-scraper`) Actor

Welcome to the Jungle jobs scraper: search welcometothejungle.com by keyword, country and city, filter by contract type, remote policy and language, and get title, company, salary, location, sectors and a description snippet. Monitor mode returns only new jobs.

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

## Pricing

from $1.68 / 1,000 result items

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Jobs Scraper

Search Welcome to the Jungle (welcometothejungle.com) by keyword, country and city, and get one flat row per job: title, company, location, contract type, remote policy, salary range when the employer published one, publication date, sectors, a snippet of the ad and the job URL. No account and no cookies. Monitor mode turns the same search into an alert on new jobs.

**Try it:** the prefilled example returns 20 rows in about 5 seconds and costs about $0.04. Results cost $2.10 per 1,000.

- **Price:** $2.10 per 1,000 jobs with no start fee, about 30% below the per-job price of the most-used Welcome to the Jungle actor in the Store (checked 2026-11-04).
- **Speed:** 50 jobs per request; the 20-row example runs in about 5 seconds on the platform (4.6 s and 5.5 s in two runs).
- **Filters on WTTJ's side:** country, city or region, contract type, remote policy and ad language, so you pay only for jobs that match.
- **Monitor mode:** a scheduled task returns only jobs it has not seen before, newest first.

### What you get

Real rows from the example dataset, which is the prefilled input (`queries: ["python", "data analyst"]`, `country: "FR"`, 10 per keyword):

| title / company | location | contract | remote | salary | published | query / rank |
|---|---|---|---|---|---|---|
| Senior Backend Engineer Python, équipe Awareness H/F / Bluecoders | Paris, France | Full-Time | Full remote | 60,000-65,000 EUR yearly | 2026-11-04 | python / 1 |
| Data Analyst Marketing F/H / Nickel | Charenton-Le-Pont, France | Full-Time | Occasional remote | 44,000-49,000 EUR yearly | 2026-11-04 | data analyst / 2 |
| Stage Data Analyst (F/H) / Dalma | Paris, France | Internship | Occasional remote | 1,200 EUR monthly | 2026-11-04 | data analyst / 1 |
| Développeur(se) Python/Devops - Services Financiers - Paris / Sopra Steria | Paris, France | Full-Time | Hybrid (regular remote days) |  | 2026-11-03 | python / 5 |
| Data Analyst (Data Partner) – m/f/d / Voyage Privé | Aix-En-Provence, France | Full-Time | Full remote |  | 2026-11-04 | data analyst / 5 |

One full row:

```json
{
  "id": "NICKE_w0jx1Jb",
  "url": "https://www.welcometothejungle.com/en/companies/nickel/jobs/data-analyst-marketing-f-h_charenton-le-pont_NICKE_w0jx1Jb",
  "scrapedAt": "2026-11-04T12:28:46.751707Z",
  "jobReference": "NICKE_w0jx1Jb",
  "title": "Data Analyst Marketing F/H",
  "company": "Nickel",
  "companySlug": "nickel",
  "companyUrl": "https://www.welcometothejungle.com/en/companies/nickel",
  "companySize": "Between 250 and 2,000 employees",
  "companyEmployees": 850,
  "location": "Charenton-Le-Pont, France",
  "locations": [
    "Charenton-Le-Pont, France"
  ],
  "city": "Charenton-Le-Pont",
  "countryCode": "FR",
  "contractType": "Full-Time",
  "contractTypeCode": "FULL_TIME",
  "contractDurationMonths": null,
  "remotePolicy": "Occasional remote",
  "remote": "punctual",
  "salaryMin": 44000,
  "salaryMax": 49000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "yearly",
  "experienceYearsMin": 5,
  "educationLevel": "BAC_5",
  "department": null,
  "profession": null,
  "sectors": [
    "Banking",
    "FinTech / InsurTech"
  ],
  "sectorGroups": [
    "Banking / Insurance / Finance"
  ],
  "language": "fr",
  "publishedAt": "2026-11-04T09:00:00.000+01:00",
  "snippet": "🏅 A propos de vous Vous justifiez d'au moins 5 années d'expérience dans l'analyse de données. Vous avez une maîtrise avancée de SQL. Une première expérience avec Google Cloud Platform (BigQuery, Data Studio, etc.) et Git est appréciée. Vous faites preuve d'écoute, de synthèse et vous avez une bonne...",
  "profile": null,
  "query": "data analyst",
  "rank": 2
}
```

Full row: `id` / `jobReference`, `url`, `title`, `company`, `companySlug`, `companyUrl`, `companySize`, `companyEmployees`, `location`, `locations`, `city`, `countryCode`, `contractType`, `contractTypeCode`, `contractDurationMonths`, `remotePolicy`, `remote`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `experienceYearsMin`, `educationLevel`, `department`, `profession`, `sectors`, `sectorGroups`, `language`, `publishedAt`, `snippet`, `profile` (filled with `includeProfile: true`), `query`, `rank`, `scrapedAt`.

`id` is WTTJ's job reference, so a job found by two keywords is one row and monitor mode tracks it across runs. `snippet` is the first 300 characters of the ad's profile section as plain text. E-mail addresses and phone numbers in the snippet and profile are removed.

### Use cases

- **Daily job alert.** One saved task per search (`"queries": ["product manager"]`, `"location": "Paris"`, `"remote": ["fulltime", "partial"]`) in monitor mode, scheduled every morning. Each run returns only the jobs that were not there yesterday.
- **Hiring signal for sales and recruiting.** Track which French and European companies are hiring for your niche, with company size and sector on every row.
- **Salary and market research.** Pull a few hundred ads for a role and compare published salary ranges, contract types and remote policies across cities.

### Try it

Hit **Start**: the prefilled input searches `python` and `data analyst` in France, 10 jobs per keyword, 20 rows in total. Add a `location` such as `Lyon` or `London`, pick `contractType: ["INTERNSHIP"]` for internships, or `remote: ["fulltime"]` for full remote. Leave `queries` empty to list every job that matches the filters.

**Monitor mode.** Save the input as a task and set:

```json
{
  "mode": "monitor",
  "monitorStateId": "pm-paris-daily",
  "queries": ["product manager"],
  "country": "FR",
  "location": "Paris",
  "webhookUrl": "https://your-endpoint.example.com/hook"
}
```

Put the task on a schedule (Apify, Schedules, cron `0 7 * * *` for daily). Monitor mode always reads the search newest first, so a fresh ad is not buried behind older, better-matching ones. Each run returns only jobs whose id it has not seen before; an edited ad does not come back as new. Point `webhookUrl` or the Telegram fields at your own channel to get the new jobs pushed to you.

### Input

| Field | Meaning | Default |
|---|---|---|
| `queries` | Keywords, one per line; empty = every job matching the filters | empty |
| `country` | Office country, e.g. `FR`, `GB`, `ES`, `BE`, `DE` | any |
| `location` | City, region or department as WTTJ spells it, e.g. `Paris`, `Lyon`, `Ile-de-France` | empty |
| `contractType` | `FULL_TIME`, `PART_TIME`, `TEMPORARY`, `INTERNSHIP`, `APPRENTICESHIP`, `FREELANCE`, `VIE`, `OTHER` | all |
| `remote` | `fulltime` (full remote), `partial` (hybrid), `punctual` (occasional), `no`, `unknown` | all |
| `language` | Language of the ad: `fr`, `en`, `es`, `de`, `cs`, `sk` | all |
| `sortBy` | `relevance` or `date` (newest first); monitor mode always uses `date` | `relevance` |
| `includeProfile` | Add the whole profile section of the ad as plain text | `false` |
| `maxResultsPerQuery` | Stop each keyword after this many jobs (at most 1,000) | `100` |
| `maxItems` | Stop the whole run after this many rows | `100` |
| `mode` | `scrape`, or `monitor` for new jobs only | `scrape` |
| `monitorStateId`, `webhookUrl`, `telegramBotToken`, `telegramChatId` | Monitor-mode state key and alert targets | empty |

### Pricing

| Event | Price |
|---|---|
| result | $0.0021 per job ($2.10 per 1,000) |
| monitor-check | $0.005 per monitor run |
| change | $0.0021 per new job in monitor mode |

Apify Store discounts: SILVER -10%, GOLD and higher -20% on every event.

You pay only for rows that are pushed, and a search that finds nothing charges no result events. Apify platform usage is billed by Apify on top; the example run used about $0.0003 of it.

**Found it useful?** A short review on the Store page helps other people find this actor. If a search misbehaves, open an issue on the actor page.

### Related actors

- [LinkedIn Jobs Scraper](https://apify.com/datahamster/linkedin-jobs-scraper) for the same roles on LinkedIn, in France or anywhere else.
- [SEEK Scraper](https://apify.com/datahamster/seek-scraper) for jobs in Australia and New Zealand.
- [Glassdoor Jobs Scraper: Salary Estimates, Ratings, Monitor](https://apify.com/datahamster/glassdoor-jobs) for employer ratings and salary estimates next to the postings.
- [Career Site Jobs Monitor: Greenhouse, Lever, Ashby, Workday](https://apify.com/datahamster/ats-jobs) to watch a specific employer's own career site.

### Limits

- Welcome to the Jungle's search returns at most 1,000 jobs per keyword and filter set. A broader search ends there with a warning in the log (`WTTJ_STATS.cappedQueries`); split it by country, city or contract type.
- `location` must match the way WTTJ spells the city, region or department (`Paris`, `Ile-de-France`, `Hauts-de-Seine`). Upper or lower case both work. A location with no jobs at all ends the run as `no_matches` with a warning.
- About half of the ads have no profile section (9 of 20 in the example run), so their `snippet` is empty.
- Salary fields are filled only when the employer published a range, and they are copied as WTTJ stores them.

### FAQ

**Do I need a Welcome to the Jungle account or cookies?** No. The actor reads the same public job search that welcometothejungle.com runs for a visitor who is not signed in.

**Why did my keyword return nothing?** Either WTTJ has no jobs for it with your filters, or the `location` matched nothing. The `RUN_SUMMARY` record in the run's key-value store has `emptyReason`, and `WTTJ_STATS` lists `emptyQueries` and `unresolvedLocation`.

**Can I get the recruiter's name or contact details?** No. Rows hold job and company data. The ad text can still mention people by name, as the employer wrote it, but e-mail addresses and phone numbers are removed from it.

### Changelog

- 0.1: initial release with keyword search, country, city or region, contract type, remote policy and ad language filters, sort by date, optional profile text, and monitor mode for new jobs.

# Actor input Schema

## `queries` (type: `array`):

Job keywords, one per line, e.g. "python", "product manager", "stage marketing". Each keyword is a separate Welcome to the Jungle search with the filters below. Leave empty to list every job that matches the filters.

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

Keep only jobs with an office in this country. Example: FR.

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

City, region or department as Welcome to the Jungle spells it, e.g. "Paris", "Lyon", "Ile-de-France", "London". Upper or lower case both work. Leave empty for the whole country.

## `contractType` (type: `array`):

Keep only these contract types, e.g. \["FULL_TIME", "INTERNSHIP"]. Empty = all.

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

Keep only these remote policies, e.g. \["fulltime"] for full remote. Empty = all.

## `language` (type: `array`):

Keep only ads written in these languages, e.g. \["en"] for English-language ads. Empty = all.

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

Welcome to the Jungle's sort order. Monitor mode always sorts by date. Example: date.

## `includeProfile` (type: `boolean`):

true = add the whole "profile" section of the ad (what the employer is looking for) as plain text, with contacts removed. Every row has a 300-character snippet of it either way. Example: false.

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

Stop each keyword after this many jobs. Welcome to the Jungle returns at most 1,000 jobs per search, so split broad searches by country, city or contract type. Example: 100.

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

Stop the whole run after this many jobs (you are charged only for pushed jobs). Example: 20.

## `mode` (type: `string`):

scrape = full results; monitor = only new/changed items since the previous run of this task

## `monitorStateId` (type: `string`):

Optional state id when not running as a saved task (monitor mode)

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

POST a change summary here in monitor mode

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

Optional: bot token for monitor-mode change summaries

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

Optional: chat id that receives monitor-mode summaries

## Actor input object example

```json
{
  "queries": [
    "python",
    "data analyst"
  ],
  "country": "FR",
  "location": "",
  "sortBy": "relevance",
  "includeProfile": false,
  "maxResultsPerQuery": 10,
  "maxItems": 20,
  "mode": "scrape"
}
```

# Actor output Schema

## `results` (type: `string`):

All pushed rows (dataset, JSON)

## `resultsTable` (type: `string`):

Dataset in the Console viewer

## `runSummary` (type: `string`):

RUN_SUMMARY record

# 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 = {
    "queries": [
        "python",
        "data analyst"
    ],
    "country": "FR",
    "maxResultsPerQuery": 10,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datahamster/welcome-to-the-jungle-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": [
        "python",
        "data analyst",
    ],
    "country": "FR",
    "maxResultsPerQuery": 10,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("datahamster/welcome-to-the-jungle-jobs-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 '{
  "queries": [
    "python",
    "data analyst"
  ],
  "country": "FR",
  "maxResultsPerQuery": 10,
  "maxItems": 20
}' |
apify call datahamster/welcome-to-the-jungle-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datahamster/welcome-to-the-jungle-jobs-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/kv7unhbJBMDhtONO2/builds/tq6VIqVdStzgQL8hz/openapi.json
