# HelloWork Jobs Scraper — Salaries & Company Data (`haketa/hellowork-jobs-scraper`) Actor

Scrape current HelloWork jobs across France with salaries, contracts, remote status, locations, skills, full descriptions, requirements, company profiles and job URLs. Search multiple keywords and cities, apply flexible filters, and export clean French recruitment data to JSON, CSV or Excel.

- **URL**: https://apify.com/haketa/hellowork-jobs-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

## 🇫🇷 HelloWork Jobs Scraper — Salaries, Skills, Details & Company Data

Extract comprehensive job postings and recruitment intelligence from **[HelloWork.com](https://www.hellowork.com)** — France's leading employment platform. This **HelloWork jobs scraper** enables you to **scrape HelloWork** by job keyword, location, or direct search URLs to harvest thousands of structured vacancies including **job titles, employer names, company profiles, logos, published salaries (annual, monthly, hourly), contract classifications (CDI, CDD, Alternance, Stage, Intérim), remote work policies, candidate skill tags, educational criteria, full description text, and direct application links**.

Export your data directly to **JSON, CSV, Excel, XML**, or stream via **Apify REST API & Webhooks**.

[![Actor](https://img.shields.io/badge/Apify-Actor-00b04f?style=flat-square\&logo=apify)](https://apify.com/haketa/hellowork-jobs-scraper)
[![Country](https://img.shields.io/badge/Country-France%20%F0%9F%87%AB%F0%9F%87%B7-0055a5?style=flat-square)](https://apify.com/haketa/hellowork-jobs-scraper)
[![Salary](https://img.shields.io/badge/Salary-Published%20%26%20Estimates-brightgreen?style=flat-square)](https://apify.com/haketa/hellowork-jobs-scraper)
[![Full description](https://img.shields.io/badge/Descriptions-Full%20Text%20%2B%20HTML-success?style=flat-square)](https://apify.com/haketa/hellowork-jobs-scraper)
[![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-2b7489?style=flat-square)](https://apify.com/haketa/hellowork-jobs-scraper)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Deep%20Pages-blue?style=flat-square)](https://apify.com/haketa/hellowork-jobs-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained-Active%202026-brightgreen?style=flat-square)](https://apify.com/haketa/hellowork-jobs-scraper)

***

### ⚡ At a glance

| Feature | Details & Support |
| :--- | :--- |
| **Target Website** | `hellowork.com` (France-wide national and regional listings) |
| **Target Data** | Job postings, verified employers, compensation bands, required skills, full text descriptions |
| **Search Strategies** | Keyword combinations, Location filters (city/department/region), Direct HelloWork URLs |
| **Contract Filters** | CDI, CDD, Intérim (Travail temporaire), Stage, Alternance, Freelance, Indépendant |
| **Pagination Depth** | Continuous automated pagination unlocked for **1,000+ jobs** |
| **Deduplication** | Automatic de-duplication across queries by canonical `jobId` |
| **Enrichment Mode** | Optional deep parsing for full qualifications, salary percentiles, and employer data |
| **Export Formats** | JSON, CSV, XLSX, XML, RSS, HTML Table, Apify Dataset API |
| **Automation** | Scheduled daily/weekly runs, Zapier, Make.com, Webhooks, Python/Node.js SDKs |

***

### 🔎 Why scrape HelloWork?

[HelloWork](https://www.hellowork.com) represents one of the largest active hiring repositories in Western Europe, featuring over 500,000 active postings spanning every economic sector in France. From senior software engineers (*développeur backend*) in Paris to sales leads (*commercial*) in Lyon and healthcare staff (*infirmier*) in Marseille, HelloWork centralizes the French labor market.

Accessing structured **HelloWork recruitment data** unlocks essential commercial advantages:

- 🧲 **Executive & Tech Recruitment**: Source active roles with exact tech stack tags and seniority requirements before standard aggregators index them.
- 💰 **French Salary Benchmarking**: Extract transparent French compensation ranges (`salaryMin`/`salaryMax` in EUR) and comparative salary percentiles.
- 📊 **Labor Market Analytics**: Gauge demand shifts between permanent contracts (CDI) and flexible arrangements (CDD, Intérim, Freelance).
- 🏢 **B2B Growth & Lead Generation**: Discover companies undergoing active team expansions as high-probability B2B prospects.
- 📰 **Job Board Aggregation**: Maintain a fully automated, real-time pipeline of French vacancies for regional or niche career portals.
- 🤖 **AI & Semantic Matching**: Ingest comprehensive French job specifications for training LLMs, semantic parsers, and automated resume screeners.

***

### ⚖️ HelloWork Jobs Scraper vs. Generic Scraping

| Capability | HelloWork Jobs Scraper | Generic Scrapers |
| :--- | :--- | :--- |
| **1,000+ Deep Pagination** | ✅ Seamless multi-page crawling without token caps | ❌ Hard capped after 2-3 pages |
| **Fast Pure-HTTP Engine** | ✅ Blazing fast `got-scraping` (500 items in ~2 mins) | ❌ Slow headless browsers (15+ mins) |
| **Detailed Salary Breakdown** | ✅ Published base salaries + HelloWork market estimates | ❌ Plain unformatted text strings |
| **Contract Type Normalization** | ✅ Normalized standard taxonomy (CDI, CDD, Stage, etc.) | ❌ Inconsistent raw tags |
| **Duplicate Prevention** | ✅ In-memory deduplication via stable numeric `jobId` | ❌ High duplicate rate across queries |
| **Taxonomy & Skills Parsing** | ✅ Normalized `jobDomain`, `profession`, and `skills` arrays | ❌ Generic text blobs without taxonomy |

***

### ✨ Features & Extraction Capabilities

- 🔍 **Keyword × Location Matrix**: Pair multiple job queries with multiple locations; every combination runs in parallel and deduplicates automatically.
- 📍 **Granular French Locations**: Search specific metropolitan areas (`Paris`, `Lyon`, `Toulouse`, `Nantes`, `Bordeaux`) or leave blank for France-wide coverage.
- 📑 **Uncapped Deep Crawling**: Walks the `p=1`, `p=2`, `p=3` pagination sequence effortlessly up to thousands of matching vacancies.
- 🏢 **Employer Intelligence**: Extracts hiring organization names, confidential employer tags, official HelloWork company URLs, and high-res logos.
- 💶 **Structured Compensation**: Separates disclosed base compensation (`salaryMin`, `salaryMax`, `salaryPeriod`) from algorithmic market estimates.
- 🧑‍💻 **Technical Skills & Tags**: Gathers structured skill tags (e.g., Python, React, Docker, Gestion de projet) extracted straight from page metadata.
- 📄 **Clean Text & HTML Options**: Delivers sanitized, plain-text descriptions alongside optional formatted HTML for exact visual rendering.

***

### 🌍 Supported Regions & Major Hiring Hubs

The scraper covers all 18 administrative regions of France and overseas territories:

- **Île-de-France**: Paris, Boulogne-Billancourt, Saint-Denis, Nanterre, Versailles
- **Auvergne-Rhône-Alpes**: Lyon, Grenoble, Saint-Étienne, Clermont-Ferrand, Annecy
- **Provence-Alpes-Côte d'Azur**: Marseille, Nice, Toulon, Aix-en-Provence, Cannes
- **Occitanie**: Toulouse, Montpellier, Nîmes, Perpignan
- **Nouvelle-Aquitaine**: Bordeaux, Limoges, Poitiers, Pau, La Rochelle
- **Hauts-de-France**: Lille, Amiens, Roubaix, Tourcoing, Dunkerque
- **Pays de la Loire**: Nantes, Angers, Le Mans, Saint-Nazaire
- **Grand Est**: Strasbourg, Reims, Metz, Nancy, Mulhouse
- **Bretagne**: Rennes, Brest, Quimper, Lorient
- **Normandie**: Rouen, Le Havre, Caen

***

### 🎯 High-Impact Use Cases

#### 1. French Recruitment & Headhunting

Target active vacancies filtered by contract (e.g., CDI only) and remote preference. Get direct apply URLs and contact routing without manual search repetition.

#### 2. Corporate HR & Compensation Consulting

Build empirical compensation tables across French departments to establish realistic compensation bands for competitive talent acquisition.

#### 3. B2B Sales & Outbound Prospecting

Growing engineering and commercial teams represent primary buyers for SaaS, recruiting tools, and managed services. Trigger outreach based on new openings.

#### 4. Career Aggregators & Graduate Portals

Populate specialized boards catering to apprenticeships (*alternance*) and student internships (*stage de fin d'études*).

***

### 📥 Input Parameters

The actor accepts standard JSON parameters configured via the Apify Console or API:

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `searchKeywords` | Array | `["développeur"]` | Target job keywords, professions, or technologies. |
| `locations` | Array | `["Paris"]` | Target cities, departments, or regions (leave empty for all France). |
| `startUrls` | Array | `[]` | Direct search or individual job URLs to scrape. |
| `contractTypes` | Array | `[]` | Filter by `CDI`, `CDD`, `Travail_temp`, `Stage`, `Alternance`, `Freelance`. |
| `remoteOnly` | Boolean | `false` | Restrict extraction to remote or hybrid opportunities. |
| `postedWithinDays` | Integer | `0` | Filter listings published within the last N days (0 = disabled). |
| `minSalary` | Integer | `0` | Minimum annual salary threshold in EUR (0 = disabled). |
| `includeDetails` | Boolean | `false` | Visit individual job pages to extract full text, skills, and requirements. |
| `includeDescriptionHtml`| Boolean | `false` | Include formatted raw HTML alongside clean description text. |
| `maxPagesPerQuery`| Integer | `0` | Maximum pages per keyword/location query (0 = unlimited pagination). |
| `maxItems` | Integer | `50` | Maximum total listings to collect across the entire run. |
| `maxConcurrency` | Integer | `8` | Parallel request concurrency for detail page fetching. |
| `proxyConfiguration` | Object | `{ "useApifyProxy": false }` | Direct connections run fastest; enable proxy if executing high-frequency queries. |

#### Input JSON Example (Fast Search Mode)

```json
{
  "searchKeywords": ["data engineer", "devops"],
  "locations": ["Paris", "Lyon"],
  "contractTypes": ["CDI"],
  "remoteOnly": false,
  "includeDetails": false,
  "maxPagesPerQuery": 0,
  "maxItems": 100,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

#### Input JSON Example (Deep Enriched Mode)

```json
{
  "searchKeywords": ["responsable commercial"],
  "locations": ["Bordeaux"],
  "contractTypes": ["CDI"],
  "includeDetails": true,
  "maxPagesPerQuery": 0,
  "maxItems": 200,
  "maxConcurrency": 10
}
```

***

### 📤 Output Data Structure

The actor outputs clean, normalized records directly into the Apify dataset.

#### Sample Output Record

```json
{
  "jobId": "84879392",
  "title": "Développeur Fullstack React / Node.js H/F",
  "company": "TechInnov France",
  "companyConfidential": false,
  "companyUrl": "https://www.hellowork.com/fr-fr/entreprises/techinnov-france-166807.html",
  "companyLogoUrl": "https://f.hellowork.com/img/entreprises/160_160/203890.png",
  "location": "Paris - 75002",
  "city": "Paris",
  "postalCode": "75002",
  "region": "Île-de-France",
  "countryCode": "FR",
  "contractType": "CDI",
  "employmentType": "FULL_TIME",
  "remoteWork": "Télétravail partiel",
  "salaryText": "45 000 - 55 000 € / an",
  "salaryMin": 45000,
  "salaryMax": 55000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "estimatedSalaryMedian": 48500,
  "industry": ["Secteur informatique", "Éditeur de logiciels"],
  "profession": "developpeur",
  "jobDomain": "informatique",
  "jobFunction": "developpement web",
  "occupationalCategory": "Informatique",
  "skills": ["React", "Node.js", "TypeScript", "PostgreSQL", "Docker"],
  "tags": ["cdi", "fullstack", "react", "nodejs", "paris"],
  "educationRequirements": ["Bac +5 / Master"],
  "experienceRequirements": "24 months of experience",
  "experienceMonths": 24,
  "requirements": "Vous justifiez d'au moins 2 ans d'expérience sur React et Node.js...",
  "description": "Dans le cadre de notre forte croissance, nous recrutons un Développeur Fullstack...",
  "datePosted": "2026-11-04T09:45:13.000Z",
  "validThrough": "2026-12-15T09:45:13.000Z",
  "reference": "REF-PARIS-DEV-2026",
  "directApply": true,
  "applicationType": "ATS",
  "detailEnriched": true,
  "searchKeyword": "développeur",
  "searchLocation": "Paris",
  "searchPage": 1,
  "url": "https://www.hellowork.com/fr-fr/emplois/84879392.html",
  "scrapedAt": "2026-11-10T13:15:45.281Z"
}
```

#### 📋 Output Fields Specification & Coverage

| Field Category | Field Name | Type | Coverage | Description |
| :--- | :--- | :--- | :--- | :--- |
| **Core Identifiers** | `jobId` | String | 🟢 High (100%) | Unique HelloWork listing ID (used for deduplication). |
| | `title` | String | 🟢 High (100%) | Published vacancy title. |
| | `url` | String | 🟢 High (100%) | Canonical URL to the listing on hellowork.com. |
| | `reference` | String | 🟢 High (92%) | Employer or agency job requisition reference code. |
| **Employer Profile** | `company` | String | 🟢 High (99%) | Employer name (null when confidential). |
| | `companyConfidential`| Boolean | 🟢 High (100%) | Indicates whether employer name is intentionally hidden. |
| | `companyUrl` | String | 🟢 High (94%) | Direct link to employer profile on HelloWork. |
| | `companyLogoUrl` | String | 🟡 Conditional | Official company logo image link when hosted. |
| | `industry` | Array | 🟢 High (95%) | Primary industry sectors of the hiring entity. |
| **Location & Date** | `location` | String | 🟢 High (100%) | Human-readable location string (City - Postal Code). |
| | `city` / `postalCode` | String | 🟢 High (88%) | Parsed French city and 5-digit postal code. |
| | `region` / `countryCode`| String | 🟢 High (98%) | French administrative region and ISO country code (FR). |
| | `datePosted` | String | 🟢 High (100%) | ISO publication timestamp. |
| | `validThrough` | String | 🟢 High (95%) | Application expiration deadline. |
| **Contract & Comp** | `contractType` | String | 🟢 High (100%) | Contract type (CDI, CDD, Intérim, Alternance, Stage). |
| | `remoteWork` | String | 🟡 Conditional | Remote work specification (Télétravail partiel / complet). |
| | `salaryText` | String | 🟡 Conditional | Published raw salary text label. |
| | `salaryMin` / `salaryMax`| Number | 🟡 Conditional | Parsed minimum and maximum compensation in EUR. |
| | `salaryCurrency` | String | 🟡 Conditional | Currency code (typically EUR). |
| | `salaryPeriod` | String | 🟡 Conditional | Cadence of compensation (year, month, hour). |
| | `estimatedSalaryMedian`| Number | 🟡 Conditional | HelloWork algorithmic market benchmark estimate. |
| **Qualifications** | `skills` | Array | 🟢 High (96% detail) | Normalized technology and competency tags. |
| | `requirements` | String | 🟢 High (85% detail) | Extracted candidate requirement summary. |
| | `educationRequirements`| Array | 🟢 High (93% detail) | Educational qualifications (Master, Bac+3, etc.). |
| | `experienceMonths` | Integer | 🟡 Conditional | Explicit required professional experience in months. |
| | `description` | String | 🟢 High (99% detail) | Clean, full-text job description without HTML tags. |

***

### 🔁 Pagination, Scale & High-Throughput Crawling

The scraper handles high-volume extraction with zero manual pagination:

- **Automatic Traversal**: Walks through `?p=1`, `?p=2`, etc., gathering 25 listings per page until `maxItems` is satisfied.
- **Zero Page Bottlenecks**: Set `maxPagesPerQuery: 0` to enable continuous deep crawling across thousands of listings.
- **De-duplication Guarantee**: In-memory hash set tracks all observed `jobId`s, preventing duplicates across overlapping searches.
- **Lightweight Footprint**: Consumes under 250 MB RAM during high-speed list scraping; operates easily on 512 MB instances.

***

### 🛠️ Step-by-Step Walkthrough

1. **Configure Parameters**: Navigate to the **Input** tab on the Apify Console. Enter your target keywords and French locations.
2. **Select Collection Mode**: Keep `includeDetails` turned off for lightning-fast overview scraping, or enable it for complete job descriptions and skill arrays.
3. **Execute Run**: Click **Start**. The actor logs live progress showing pages parsed and unique items saved.
4. **Export Results**: Once finished, download the dataset in JSON, CSV, or Excel formats, or sync directly into external databases via the Apify API.

#### Programmatic Execution via Python

```python
from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchKeywords": ["data scientist", "machine learning engineer"],
    "locations": ["Paris", "Lyon"],
    "contractTypes": ["CDI"],
    "includeDetails": False,
    "maxItems": 150
}

run = client.actor("haketa/hellowork-jobs-scraper").call(run_input=run_input)
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Retrieved {len(dataset_items)} French job listings.")

## Convert directly into Pandas DataFrame
df = pd.DataFrame(dataset_items)
print(df[["title", "company", "location", "contractType", "salaryText"]].head())
```

#### Programmatic Execution via Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/hellowork-jobs-scraper').call({
    searchKeywords: ['développeur fullstack'],
    locations: ['Nantes', 'Rennes'],
    contractTypes: ['CDI'],
    includeDetails: false,
    maxItems: 100
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Successfully scraped ${items.length} records`);
```

#### Webhook & Automation Workflow

You can set up an Apify Webhook that triggers whenever a HelloWork scrape run succeeds:

- **Slack Alert**: Post new executive vacancies directly into an internal recruiting channel.
- **Google Sheets Sync**: Append new leads automatically via Make.com or Zapier.
- **CRM Ingestion**: Pipe newly discovering hiring companies into HubSpot or Salesforce as active leads.

##### Example Apify Webhook Configuration

When integrating with Zapier or Make.com, configure an HTTP POST Webhook on Apify Console triggered on `ACTOR.RUN.SUCCEEDED`:

```json
{
  "eventType": "ACTOR.RUN.SUCCEEDED",
  "eventData": {
    "actorId": "haketa/hellowork-jobs-scraper",
    "actorRunId": "91kL0x8NmQ7Zb12",
    "defaultDatasetId": "kL89mX01Pq23Za4"
  }
}
```

***

### 📊 Supported Export Formats & Integrations

The default dataset supports immediate one-click downloads and downstream API integrations across all industry standards:

- **JSON / JSONL**: Optimized for developers, API ingestion, and vector embedding pipelines.
- **CSV**: Universal spreadsheet format compatible with Excel, Google Sheets, LibreOffice, and Airtable.
- **XLSX**: Native Microsoft Excel workbook format with column formatting.
- **XML & RSS**: Ideal for legacy content aggregators and automated RSS feed readers.
- **HTML Table**: Direct preview table for web embeds and instant browser validation.
- **Python & Node.js SDKs**: Programmatic fetching using official Apify clients.

***

### 💡 Best Practices & Pro Tips

- 🎯 **Broad vs. Local Searches**: Omit `locations` to perform an exhaustive nationwide search, or specify exact cities for local recruitment sourcing.
- ⚡ **Optimize Execution Speed**: Keep `includeDetails: false` when your primary objective is company discovery or lead generation; turn it on when you need full role requirements and compensation bands.
- 📅 **Schedule Daily or Weekly**: Set up an Apify Cron Schedule (e.g. `0 8 * * 1`) to run every Monday morning to capture all newly published French opportunities.
- 🔗 **Preserve Search Filters**: Build complex filtered searches directly on HelloWork (by industry, role level, date posted), and feed the resulting URL into `startUrls`.
- 🧩 **Multi-Keyword Synergy**: Group related French and English terms together (e.g., `["développeur web", "software engineer"]`) to catch bilingual listings.

***

### ❓ Frequently Asked Questions

**Does the scraper require a HelloWork account or API key?**\
No. The scraper accesses publicly available job listings and does not require account credentials or API tokens.

**Can I scrape jobs from across all of France at once?**\
Yes. Leave `locations` empty or pass `[""]` to query nationwide listings across all regions.

**How is data deduplication handled when running multiple keywords?**\
Each job posting on HelloWork possesses a unique numeric identifier (`jobId`). The actor maintains an in-memory registry of collected IDs, guaranteeing that each unique listing is written exactly once.

**Why do some records lack structured salary data?**\
In France, salary disclosure is voluntary and determined by individual employers. When compensation is withheld by the hiring organization, the salary fields will return `null`.

**Can I extract more than 1,000 jobs in a single execution?**\
Yes. Simply adjust `maxItems` to your desired count (e.g. `2000` or `5000`) and set `maxPagesPerQuery: 0`. The actor will automatically traverse all result pages until the quota is satisfied.

**What formats can I export the data to?**\
You can export datasets directly into JSON, CSV, XLSX, XML, or connect through Apify's REST API and Webhooks to pipe data directly into Google BigQuery, Snowflake, or PostgreSQL.

**Can I run this actor on a recurring schedule?**\
Yes. You can schedule the actor via Apify Schedules (hourly, daily, weekly) or trigger runs programmatically via API calls.

***

### 📋 Changelog

#### v1.2 (2026-11)

- 🚀 **Unlocked 1,000+ Deep Pagination**: Removed arbitrary page limits, enabling full-depth result traversal via `maxPagesPerQuery: 0`.
- ⚡ **Optimized Prefill Execution**: Streamlined default parameters ensuring test runs finish in under 30 seconds with 100% data fidelity.
- 🧼 **Clean Field Normalization**: Improved whitespace sanitization, contract taxonomy parsing, and salary extraction logic.
- 🛡️ **Schema Strict Compliance**: Validated input, output, and dataset schemas to meet strict Apify specifications.

#### v1.1 (2026-08)

- Added deep enrichment support for structured skills, candidate qualifications, and market salary estimates.
- Implemented natural de-duplication by native numeric `jobId`.

#### v1.0 (2026-08)

- Initial release featuring multi-keyword search, location selector, and direct search URL ingestion.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/hellowork-jobs-scraper/changelog.md

# Actor input Schema

## `searchKeywords` (type: `array`):

Jobs, skills or professions to search. Every keyword is combined with every location, so adding more values returns more opportunities.

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

French cities, departments or regions. Leave empty for France-wide results. Each location creates an additional search.

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

Optional HelloWork search pages or individual job URLs. These run in addition to keyword searches.

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

Select one or more contract types. Leave empty to include every contract.

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

Keep only listings that mention full, partial or occasional remote work.

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

Keep only recently posted jobs. Use 0 to disable this filter.

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

Keep jobs whose published maximum annual salary reaches this value. Jobs without salary data are excluded when set. Use 0 for no filter.

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

Visit each job page for full description, requirements, skills, precise publication date, company profile, salary estimates and application metadata.

## `includeDescriptionHtml` (type: `boolean`):

Add the original formatted HTML alongside clean text when detail enrichment is enabled.

## `maxPagesPerQuery` (type: `integer`):

Maximum pages to scrape per keyword and location query (0 = unlimited deep pagination).

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

Total number of unique jobs saved across all searches. Set to 1,000+ for large bulk exports.

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

Recommended range: 6–12. Higher values may be faster but place more load on the source.

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

Direct requests are fastest and cheapest. Enable Apify Proxy only if your network is blocked.

## Actor input object example

```json
{
  "searchKeywords": [
    "data analyst",
    "commercial",
    "infirmier"
  ],
  "locations": [
    "Paris",
    "Lyon",
    "Bordeaux"
  ],
  "startUrls": [],
  "contractTypes": [],
  "remoteOnly": false,
  "postedWithinDays": 0,
  "minSalary": 0,
  "includeDetails": false,
  "includeDescriptionHtml": false,
  "maxPagesPerQuery": 0,
  "maxItems": 50,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Direct API link to the dataset containing extracted HelloWork job listings

# 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 = {
    "searchKeywords": [
        "développeur"
    ],
    "locations": [
        "Paris"
    ],
    "startUrls": [],
    "contractTypes": [],
    "includeDetails": false,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/hellowork-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 = {
    "searchKeywords": ["développeur"],
    "locations": ["Paris"],
    "startUrls": [],
    "contractTypes": [],
    "includeDetails": False,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/hellowork-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 '{
  "searchKeywords": [
    "développeur"
  ],
  "locations": [
    "Paris"
  ],
  "startUrls": [],
  "contractTypes": [],
  "includeDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/hellowork-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/hellowork-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/8KRK4O1qwdVdZ6QM6/builds/jQOdRTrwcuuffavPB/openapi.json