# 🌴 Welcome to the Jungle Jobs Scraper (`hipersoft/welcometothejungle-scraper`) Actor

Scrape job ads from Welcome to the Jungle: title, company with size and founding year, city and country with coordinates, contract type, remote policy, salary range, sectors, benefits and key missions. Filter by keyword, city, contract or salary and export to JSON, CSV, Excel or XML.

- **URL**: https://apify.com/hipersoft/welcometothejungle-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0015 / job scraped

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🌴 Welcome to the Jungle Scraper — Jobs, Companies & Salary Ranges

Scrape **Welcome to the Jungle**, one of Europe's largest tech and startup job boards, and turn its live job ads into clean, structured data. This Welcome to the Jungle scraper collects the **job title, hiring company, city and country with coordinates, contract type, remote policy, published salary range, sectors, benefits, key missions and requirements** — plus company size and founding year on every single row. Export to **JSON, CSV, Excel or XML**, or pull it straight from the API. Fast, reliable, and you pay only per job you actually get.

![Welcome to the Jungle Scraper input form — search keywords, language, contract type, city, salary and remote filters](https://api.apify.com/v2/key-value-stores/SUfvnaFLd9z9eBCtV/records/welcometothejungle-scraper-input.png)

### What does the Welcome to the Jungle Scraper do?

The Welcome to the Jungle Scraper is a job-board crawler that extracts public job ads into a flat, analysis-ready table. Search by keyword the way you would on the site (`développeur`, `data analyst`, `product manager`), or leave the keyword empty and sweep the whole current board. Both the French and English editions are supported.

What makes this dataset unusual is how much of it is already structured. Most job boards bury pay inside free text; here the **salary minimum, maximum, currency and period are separate numeric fields**, so you can sort and average them straight away. Every office carries **latitude and longitude**, so results drop onto a map with no geocoding step. And each employer arrives with its **headcount, founding year, sectors and logo** attached.

### What data can you scrape from Welcome to the Jungle?

![Example Welcome to the Jungle job record — every field of one scraped job ad with real values including salary range and coordinates](https://api.apify.com/v2/key-value-stores/SUfvnaFLd9z9eBCtV/records/welcometothejungle-scraper-output.png)

| Data point | Description |
|---|---|
| `title` | Job title exactly as published |
| `url` | Direct link to the job ad |
| `companyName` | Hiring company |
| `companyUrl` | Link to the company profile |
| `companySummary` | One-line description of the employer |
| `companySize` | Number of employees |
| `companyFoundedYear` | Year the company was founded |
| `companyLogo` | Company logo image URL |
| `companyLabels` | Employer badges such as "great place to work" |
| `contractType` | Permanent, fixed-term, internship, apprenticeship, freelance, VIE… |
| `contractDurationMinimum` / `contractDurationMaximum` | Contract length in months, where published |
| `remote` | Remote policy — fully remote, partial, occasional or none |
| `experienceLevelMinimum` | Years of experience required |
| `educationLevel` | Required education level |
| `profession` | Normalised job role (e.g. Software Developer) |
| `professionCategory` / `professionSubCategory` | Role family and sub-family |
| `salaryMinimum` / `salaryMaximum` | Published salary range as numbers |
| `salaryYearlyMinimum` | Salary normalised to a yearly figure |
| `salaryCurrency` / `salaryPeriod` | Currency and whether the figure is yearly or monthly |
| `offices` | Every office: city, district, state, country, latitude, longitude |
| `cities`, `countries` | Flat arrays of city and country names |
| `locationsText` | All cities in one readable string |
| `sectors` | Company sectors (SaaS, Fintech, Health…) |
| `benefits` | Perks listed on the ad |
| `keyMissions` | The role's main responsibilities, as a clean array |
| `requirements` / `requirementsText` | Candidate requirements, HTML and plain text |
| `summary` | Short summary of the role |
| `publishedAt` | Publication date (ISO 8601) |
| `scrapedAt` | When the row was collected (ISO 8601) |

### Use cases

- **Salary benchmarking** — thousands of ads with structured pay ranges, ready to average by role, city or seniority.
- **Recruitment market research** — track hiring demand by sector, contract type, remote policy and company size over time.
- **Build a job board or aggregator** — keep a European tech jobs feed fresh with a scheduled run and one row per ad.
- **Startup and scale-up intelligence** — see which companies are hiring, how big they are, how old they are and what they pay.
- **Talent sourcing** — filter to remote-friendly roles in a city or a salary band and push matches into Slack or email.
- **Map and geo analysis** — every office ships with coordinates, so hiring maps need no geocoding.
- **Lead generation for recruiters** — find employers actively opening roles, with company profile and logo attached.
- **Academic and economic research** — build a longitudinal dataset of the European tech labour market from public postings.

### How to scrape Welcome to the Jungle job data

1. Add the **Welcome to the Jungle Scraper** to your Apify account and open the input form.
2. Type one or more **search keywords** — a role (`développeur`, `data analyst`) or a skill. Leave it empty to collect the whole current board.
3. Pick the **language** edition, and optionally narrow by **contract type, city, country, company, sector, minimum salary, remote-friendly** or **published within N days**.
4. Set **Max items** if you want a smaller sample.
5. Click **Start**, then download the dataset as JSON, CSV, Excel or XML — or fetch it from the Apify API.

### Input

#### Example input

```json
{
  "searchQueries": ["développeur", "data analyst"],
  "language": "fr",
  "contractTypes": ["full_time"],
  "city": "Paris",
  "minSalary": 45000,
  "remoteOnly": true,
  "publishedWithinDays": 30,
  "maxItems": 500
}
```

#### Input reference

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | Keywords to search — matches job titles, companies and descriptions |
| `language` | string | `fr` or `en` — which language edition to read |
| `contractTypes` | array | Permanent, part time, fixed-term, internship, apprenticeship, freelance, VIE, other |
| `remoteOnly` | boolean | Keep only roles that are fully remote or offer regular home working |
| `city` | string | Keep only ads in a matching city (accent-insensitive) |
| `country` | string | Keep only ads in a matching country |
| `company` | string | Keep only ads from employers whose name matches |
| `sector` | string | Keep only ads in a matching sector |
| `minSalary` | integer | Keep only ads advertising at least this yearly salary |
| `publishedWithinDays` | integer | Keep only ads published in the last N days (0 = no limit) |
| `maxItemsPerQuery` | integer | Cap per keyword (0 = no cap) |
| `maxItems` | integer | Overall cap for the run (0 = no cap) |
| `proxyConfiguration` | object | Optional proxy settings — not required by default |

### Output

Every job is one flat record:

```json
{
  "id": "1783492",
  "url": "https://www.welcometothejungle.com/fr/companies/sii/jobs/developpeur-python-angular-h-f_bordeaux",
  "title": "Développeur Python / Angular (H/F)",
  "companyName": "Groupe SII",
  "companyUrl": "https://www.welcometothejungle.com/fr/companies/sii",
  "companySummary": "Conseil en technologies pour la transformation numérique des grands-comptes.",
  "companySize": 16000,
  "companyFoundedYear": 1979,
  "companyLabels": ["great-place-to-work"],
  "contractType": "full_time",
  "remote": "partial",
  "profession": "Développeur de logiciels",
  "professionCategory": "Technologie et ingénierie",
  "salaryMinimum": 36000,
  "salaryMaximum": 47000,
  "salaryYearlyMinimum": 36000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "yearly",
  "offices": [
    { "city": "Bordeaux", "state": "Nouvelle-Aquitaine", "district": "Gironde", "country": "France", "countryCode": "FR", "latitude": 44.8367, "longitude": -0.58105 }
  ],
  "cities": ["Bordeaux"],
  "countries": ["France"],
  "locationsText": "Bordeaux",
  "sectors": ["Logiciels", "Intelligence artificielle / Machine Learning", "IT / Digital"],
  "benefits": ["Horaires de travail flexibles", "Entre 1-2 jours de télétravail"],
  "keyMissions": ["Développer de nouveaux composants et améliorer les modules existants."],
  "publishedAt": "2026-09-06T22:04:39.000Z",
  "scrapedAt": "2026-09-07T01:28:56.358Z"
}
```

#### Output schema

| Field | Type | Description |
|---|---|---|
| `id` | string | Job ad ID |
| `reference` | string | The board's own reference for the ad |
| `url` | string (URL) | Direct link to the job ad |
| `title` | string | Job title |
| `slug` | string | URL slug of the ad |
| `companyName` | string | Employer name |
| `companySlug` | string | Employer URL slug |
| `companyUrl` | string (URL) | Employer profile page |
| `companySummary` | string | One-line employer description |
| `companyDescription` | string | Longer employer description, where published |
| `companySize` | integer | Number of employees |
| `companyFoundedYear` | integer | Year founded |
| `companyLogo` | string (URL) | Logo image |
| `companyLabels` | array | Employer badges |
| `contractType` | string | Contract type |
| `contractDurationMinimum` | number | Minimum contract length in months |
| `contractDurationMaximum` | number | Maximum contract length in months |
| `remote` | string | Remote policy |
| `experienceLevelMinimum` | number | Years of experience required |
| `educationLevel` | string | Required education level |
| `profession` | string | Normalised job role |
| `professionCategory` | string | Role family |
| `professionSubCategory` | string | Role sub-family |
| `salaryMinimum` | number | Bottom of the published salary range |
| `salaryMaximum` | number | Top of the published salary range |
| `salaryYearlyMinimum` | number | Salary normalised to a yearly figure |
| `salaryCurrency` | string | Salary currency |
| `salaryPeriod` | string | Yearly or monthly |
| `offices` | array | Objects with `city`, `district`, `state`, `country`, `countryCode`, `latitude`, `longitude` |
| `cities` | array | City names |
| `countries` | array | Country names |
| `locationsText` | string | All cities in one readable string |
| `sectors` | array | Company sectors |
| `benefits` | array | Perks listed on the ad |
| `keyMissions` | array | Main responsibilities |
| `requirements` | string | Candidate requirements (HTML) |
| `requirementsText` | string | Candidate requirements (plain text) |
| `summary` | string | Short role summary |
| `language` | string | Language edition the row came from |
| `publishedAt` | string (ISO date) | Publication date |
| `scrapedAt` | string (ISO date) | When the row was collected |

### Need job data from other markets?

- [France Travail Scraper](https://apify.com/hipersoft/francetravail-scraper) — the French public employment service
- [eJobs.ro Scraper](https://apify.com/hipersoft/ejobs-scraper) — Romania's largest job board
- [StepStone Scraper](https://apify.com/hipersoft/stepstone-scraper) — jobs across Germany, Austria and the Benelux
- [Arbeitnow Scraper](https://apify.com/hipersoft/arbeitnow-scraper) — German and English-speaking roles in Europe
- [Reed Scraper](https://apify.com/hipersoft/reed-scraper) — one of the UK's biggest job boards
- [Indeed Scraper](https://apify.com/hipersoft/indeed-scraper) — worldwide job search

### FAQ

**How many jobs can I scrape from Welcome to the Jungle?**
The board carries tens of thousands of live ads. Each keyword returns up to 1,000 results, so use several keywords — or add a city, contract type or sector filter — to sweep past that and cover the whole board. Use `maxItems` to cap a run.

**Do I need an account, a login or any setup?**
No. Add the actor, type a keyword, press Start. There is nothing to install and no credentials to supply.

**How does billing work?**
Pay per result. You are charged for each job row stored in your dataset, so a run that returns nothing costs you effectively nothing. There are no monthly platform fees to use the actor.

**Does it really include salaries?**
Yes, wherever the employer published one — and as separate numeric fields (`salaryMinimum`, `salaryMaximum`, `salaryYearlyMinimum`) with the currency and period alongside, not buried in free text. Roughly three quarters of ads in a typical run carry a range. Set `minSalary` to keep only ads above a threshold.

**Can I filter to remote jobs only?**
Yes. Tick **Remote-friendly only** and the run keeps just the fully-remote and regular-home-working ads, and you can combine it with a keyword, city or contract type.

**Can I get French and English listings?**
Both. Pick the language edition in the input. French carries the most ads; English covers the international listings.

**Which export formats are supported?**
JSON, CSV, Excel, XML and HTML table from the Apify console, plus the dataset API for programmatic access.

**How fresh is the data?**
Every run reads the board live, and each row carries `publishedAt` and `scrapedAt` timestamps. Schedule the actor hourly or daily to keep a dataset current, and use `publishedWithinDays` to keep only recent ads.

**Can I integrate this with my own tools?**
The Welcome to the Jungle Scraper can be connected with almost any cloud service or web app thanks to [integrations on the Apify platform](https://apify.com/integrations). It works with [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Airbyte](https://docs.apify.com/platform/integrations/airbyte), [GitHub](https://docs.apify.com/platform/integrations/github), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus the [Apify API](https://docs.apify.com/api/v2), JS/Python clients and MCP. Or use [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

**Is scraping Welcome to the Jungle legal?**
This scraper collects only public job listings — the same information any visitor can read on the site. It never touches candidate profiles, CVs or any personal data behind a login. You are responsible for using the data in line with applicable law and the site's terms.

### Related Actors

- [Working Nomads Scraper](https://apify.com/hipersoft/workingnomads-scraper) — curated remote jobs
- [Remote Jobs Aggregator](https://apify.com/hipersoft/remote-jobs-aggregator) — remote roles from several boards at once
- [RemoteOK Scraper](https://apify.com/hipersoft/remoteok-scraper) — remote tech jobs
- [We Work Remotely Scraper](https://apify.com/hipersoft/weworkremotely-scraper) — one of the oldest remote job boards
- [Company Jobs Scraper](https://apify.com/hipersoft/company-jobs-scraper) — careers pages of individual employers

### Notes

Original clean-room implementation. Returns only public data; you are responsible for compliance with Welcome to the Jungle's terms. Not affiliated with Welcome to the Jungle.

# Actor input Schema

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

Keywords to search. Each one runs its own search and matches job titles, companies and descriptions — for example 'développeur', 'data analyst', 'product manager' or 'marketing'. Leave empty to collect the whole current job board.

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

Which language edition of the board to read. French carries the most ads; English covers the international listings.

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

Only return these contract types. Leave empty for all.

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

Keep only roles that offer remote work (fully remote or regular home working).

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

Optional. Keep only ads in a city whose name contains this text — for example 'Paris', 'Lyon', 'Bordeaux' or 'London'. Accent-insensitive.

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

Optional. Keep only ads in a country whose name contains this text — for example 'France', 'Espagne' or 'United Kingdom'.

## `company` (type: `string`):

Optional. Keep only ads from employers whose name contains this text.

## `sector` (type: `string`):

Optional. Keep only ads whose sector contains this text — for example 'SaaS', 'Fintech' or 'Santé'.

## `minSalary` (type: `integer`):

Optional. Keep only ads advertising at least this yearly salary. Ads without a published salary are excluded when this is set. 0 = no salary filter.

## `publishedWithinDays` (type: `integer`):

Optional. Keep only ads published in the last N days. 0 = no date limit.

## `maxItemsPerQuery` (type: `integer`):

Maximum jobs to keep from each keyword (0 = as many as the source returns).

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

Overall cap on jobs collected in this run (0 = no limit).

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

Proxy settings. Not required by default. If you experience reduced results, enable Apify Proxy for the most reliable access.

## Actor input object example

```json
{
  "searchQueries": [
    "développeur"
  ],
  "language": "fr",
  "contractTypes": [],
  "remoteOnly": false,
  "minSalary": 0,
  "publishedWithinDays": 0,
  "maxItemsPerQuery": 0,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

The results as dataset items.

# 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": [
        "développeur"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/welcometothejungle-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": ["développeur"] }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/welcometothejungle-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": [
    "développeur"
  ]
}' |
apify call hipersoft/welcometothejungle-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/welcometothejungle-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/mGhgTJQNXDRkw8cpw/builds/inBaWzswTyIglZhGP/openapi.json