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

Scrape Welcome to the Jungle (WTTJ) job listings by keyword, country, city, contract type, remote policy and date. Returns one flat row per job with company, salary, full description and apply URL. No login, no browser.

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

## Pricing

from $1.00 / 1,000 job 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 (WTTJ)

Scrape job listings from [Welcome to the Jungle](https://www.welcometothejungle.com) by keyword, country, city, contract type, remote policy and publish date. Each job comes back as **one clean, flat row** with company details, salary, the full description as plain text and the direct apply URL.

No login, no cookies, no browser. Runs on plain HTTP requests, so 1,000 jobs with full descriptions take about 3–4 minutes.

### What data do you get?

| Group | Fields |
|---|---|
| Job | `title`, `url`, `applyUrl`, `contractType`, `remote`, `publishedAt`, `jobLanguage`, `profession` |
| Company | `companyName`, `companySize`, `companySectors`, `companyIndustries`, `companyCreationYear`, `companyUrl` |
| Location | `location`, `city`, `region`, `country`, `countryCode`, `address`, `zipCode`, `allLocations` |
| Salary | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText` |
| Requirements | `experienceMinYears`, `experienceLevel`, `educationLevel`, `skills`, `tools` |
| Content | `summary`, `keyMissions`, `descriptionText`, `profileText`, `recruitmentProcessText`, `benefits` |

Every item has the same keys. Missing values are `null` (or an empty list), so the export opens cleanly in Excel, Google Sheets or a database.

### Use cases

- **Job boards and aggregators:** import fresh French and European tech and startup jobs every day.
- **Recruiters and staffing agencies:** see which companies are hiring for a role, in which city, at what salary.
- **Sales teams:** hiring is a buying signal. Find companies that are recruiting for the roles your product serves.
- **Market and salary research:** compare contract types, remote policies and salary ranges across sectors.
- **Job seekers:** build your own alert for a precise search and get new jobs in a spreadsheet.

### How to use it

1. Click **Try for free** and open the **Input** tab.
2. Type one or more keywords, for example `data engineer`.
3. Optionally set a country, city, contract type, remote policy or date filter.
4. Set **Maximum results** and click **Start**.
5. Download the results from the **Output** tab as JSON, CSV, Excel or HTML, or read them through the API.

To run it every day, open **Schedules** in Apify Console, pick this Actor, and choose "Newest first" with "Last 24 hours".

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | list of text | empty | Job titles, skills or company names. Each keyword is its own search; duplicates are removed. Leave empty to get all jobs matching the filters. |
| `country` | text | all | 2-letter country code of the job location: `FR`, `GB`, `US`, `DE`, `ES`… |
| `city` | text | all | City as spelled on WTTJ: `Paris`, `Lyon`, `London`, `New York`… |
| `contractTypes` | list | all | `full_time`, `part_time`, `internship`, `apprenticeship`, `temporary`, `freelance`, `vie`, `graduate_program`, `volunteer`, `other` |
| `remote` | list | all | `fulltime` (fully remote), `partial` (hybrid), `punctual` (occasional), `no` |
| `datePosted` | choice | `any` | `any`, `24h`, `3d`, `7d`, `14d`, `30d` |
| `sortBy` | choice | `relevance` | `relevance` or `newest` |
| `maxResults` | number | `100` | Maximum jobs returned in total (1–50,000). |
| `language` | choice | `en` | `en` or `fr`. Language of labels (sectors, benefits, skills) and of job URLs. |
| `includeDetails` | yes/no | `true` | Adds full description, profile, skills, tools and apply URL. Turn off for faster listing-only runs. |
| `searchUrls` | list of URLs | empty | Job search URLs copied from welcometothejungle.com. Their query and filters are used as they are. |
| `proxyConfiguration` | proxy | off | Usually not needed. |

Example input:

```json
{
    "keywords": ["data engineer"],
    "country": "FR",
    "contractTypes": ["full_time"],
    "remote": ["partial", "fulltime"],
    "datePosted": "7d",
    "sortBy": "newest",
    "maxResults": 200
}
```

### Output example

Long text fields are shortened here.

```json
{
    "id": "e321aa3c-ea41-4372-8bb6-1f5242014e07",
    "title": "Data Engineer F/H",
    "url": "https://www.welcometothejungle.com/en/companies/cgi/jobs/data-engineer-f-h_clermont-ferrand_CGI_Xx2JZ17",
    "applyUrl": "https://cgi.njoyn.com/corp/xweb/xweb.asp?clid=21001&page=jobdetails&jobid=J1026-0454",
    "companyName": "CGI",
    "companySlug": "cgi",
    "companyUrl": "https://www.welcometothejungle.com/en/companies/cgi",
    "companySize": 15000,
    "companySectors": ["IT / Digital", "Change Management", "Big Data"],
    "companyIndustries": ["Consulting / Audit", "Tech"],
    "companyCreationYear": 1976,
    "location": "Clermont-Ferrand, Auvergne-Rhone-Alpes, France",
    "city": "Clermont-Ferrand",
    "region": "Auvergne-Rhone-Alpes",
    "country": "France",
    "countryCode": "FR",
    "address": "23 Allée Alan Turing, 63000 Clermont-Ferrand, France",
    "zipCode": "63000",
    "allLocations": ["Clermont-Ferrand, Auvergne-Rhone-Alpes, France"],
    "contractType": "full_time",
    "contractDurationMinMonths": null,
    "contractDurationMaxMonths": null,
    "remote": "partial",
    "salaryMin": 46000,
    "salaryMax": 56000,
    "salaryCurrency": "EUR",
    "salaryPeriod": "yearly",
    "salaryText": "46,000–56,000 EUR / year",
    "experienceMinYears": 4,
    "experienceLevel": "4_TO_5_YEARS",
    "educationLevel": null,
    "profession": "Data / Business Intelligence",
    "professionCategory": "Tech & Engineering",
    "publishedAt": "2026-11-16T09:41:51Z",
    "updatedAt": "2026-11-16T09:41:53.016339Z",
    "startDate": null,
    "jobLanguage": "fr",
    "summary": "Rejoignez CGI, l'une des plus grandes entreprises de conseil…",
    "keyMissions": ["Modélisation des Data Concepts d'un DataLake…"],
    "descriptionText": "Big Data, Data Science, Data analyse, Data architecture…",
    "profileText": null,
    "recruitmentProcessText": null,
    "skills": ["Technology integration"],
    "tools": ["Snowflake", "Databricks", "Python", "SQL", "Power BI"],
    "benefits": ["Between 2-3 days at home", "Company saving plan"],
    "detailsFetched": true,
    "scrapedAt": "2026-11-16T14:07:12.543Z"
}
```

### How much does it cost?

This Actor uses **pay per result**: you pay only for jobs that are returned. There is no monthly rental, and platform usage (compute, storage) is included in the price.

| Jobs returned | Price |
|---|---|
| 100 | $0.10 |
| 1,000 | $1.00 |
| 10,000 | $10.00 |

A run that finds nothing costs nothing beyond the tiny Actor start fee. You can also set a **maximum cost per run** in the run options; the Actor stops cleanly when it reaches it.

With the free Apify plan ($5 of monthly credit) you can scrape about 5,000 jobs per month.

### Reliability

- Every request is retried with backoff; search requests rotate between server hosts.
- A job is never lost because its detail page failed. It is returned from the listing data with `detailsFetched: false`.
- Results are deduplicated by job ID across keywords and URLs.
- `maxResults` and your maximum cost per run are always respected.
- Invalid input stops the run immediately with a message that says what to fix.

### FAQ

**Do I need a Welcome to the Jungle account or cookies?**
No. The Actor only reads public job listings.

**Can I get more than 1,000 jobs for one search?**
Yes. The website's search stops at 1,000 results per query. The Actor splits large searches by publish date behind the scenes, so you can collect tens of thousands of jobs in one run.

**How do I scrape only new jobs every day?**
Schedule the Actor with `sortBy: "newest"` and `datePosted: "24h"`, then deduplicate on `id` on your side.

**Which countries are covered?**
Everything listed on Welcome to the Jungle. Most jobs are in France, followed by the United States, the United Kingdom, Canada, Germany and Spain.

**Why is `salaryMin` empty for many jobs?**
Employers are not required to publish a salary. About one job in three has one.

**Why does my city filter return a job whose `city` is different?**
A job can be open in several offices. The filter matches any of them; `city` shows the first one and `allLocations` lists them all.

**Can I use it through the API or with Make, n8n or Zapier?**
Yes. Use the Apify API, the `apify-client` packages for JavaScript and Python, or the Apify integrations for those tools.

**Does it return recruiter names or contact details?**
No. The Actor returns job and company data only and collects no personal data.

### Limitations

- `publishedAt` is the date shown by Welcome to the Jungle. Employers often republish open jobs, so "Last 24 hours" includes refreshed listings, not only brand-new ones.
- Salary values are returned as the employer entered them. A few employers type `60` instead of `60000`.
- `city` must match the spelling used on the website (`Paris`, not `Paris 2e`). Search by radius around a point is available through `searchUrls`.
- Job descriptions are in the language the employer wrote them in; they are not translated.
- This Actor reads the same public search service as the website. If Welcome to the Jungle changes it, the Actor may need an update. Report problems in the **Issues** tab and they will be fixed quickly.

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

This Actor collects only publicly available job listings and no personal data. It is not affiliated with or endorsed by Welcome to the Jungle. Their terms of use restrict automated collection and commercial reuse of their content, so you are responsible for how you use the data and for complying with the laws and terms that apply to you. If you are unsure, ask a lawyer.

### Support

Found a bug or need another field? Open a ticket in the **Issues** tab. Requests are usually answered within one working day.

# Actor input Schema

## `keywords` (type: `array`):

Job titles, skills or company names to search for, exactly as you would type them on welcometothejungle.com. Each keyword runs as its own search and duplicates are removed. Leave empty to get every job that matches the filters below.

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

2-letter country code of the job location, for example FR (France), GB (United Kingdom), US (United States), DE (Germany), ES (Spain). Leave empty for all countries.

## `city` (type: `string`):

City of the job location, spelled as on Welcome to the Jungle, for example Paris, Lyon, London or New York. Leave empty for all cities.

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

Keep only jobs with one of these contract types. Leave empty for all contract types.

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

Keep only jobs with one of these remote work policies. Leave empty for all.

## `datePosted` (type: `string`):

Keep only jobs published within this period.

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

Order of results. "Most relevant" is the default order of the website. "Newest first" is best for daily monitoring.

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

Maximum number of jobs to return in total, across all keywords and URLs. You are only charged for jobs actually returned.

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

Language version of Welcome to the Jungle to read. It sets the language of labels such as sectors, benefits and skills, and of the job URLs. Job descriptions stay in the language the employer wrote them in.

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

When on, each job is enriched with the full description, candidate profile, skills, tools and the direct apply URL (one extra request per job). Turn off for faster runs that only need the listing data.

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

Paste job search URLs copied from welcometothejungle.com, for example https://www.welcometothejungle.com/en/jobs?query=product%20manager. The query and filters in the URL are used as they are; only "Date posted" and "Maximum results" from this form are applied on top.

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

Usually not needed. Enable Apify Proxy only if you see blocked requests in the log.

## Actor input object example

```json
{
  "keywords": [
    "data engineer"
  ],
  "country": "FR",
  "contractTypes": [],
  "remote": [],
  "datePosted": "any",
  "sortBy": "relevance",
  "maxResults": 100,
  "language": "en",
  "includeDetails": true,
  "searchUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped jobs, one item per job.

# 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 = {
    "keywords": [
        "data engineer"
    ],
    "country": "FR",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("flaxen_landlady/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 = {
    "keywords": ["data engineer"],
    "country": "FR",
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("flaxen_landlady/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 '{
  "keywords": [
    "data engineer"
  ],
  "country": "FR",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call flaxen_landlady/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,flaxen_landlady/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/aRysXqQ0jqfOkeyQn/builds/JcIxLVZMuChhz4uBx/openapi.json
