# HelloWork Scraper: French Job Board (`dltik/hellowork-scraper`) Actor

Scrape HelloWork jobs by keyword, city, contract type, salary range. Get title, company, location, contract (CDI/CDD/alternance/stage), salary, remote policy, full description, posted date. France's #1 generalist job board. For ATS providers, recruitment agencies, sourcing teams. $1/1K jobs.

- **URL**: https://apify.com/dltik/hellowork-scraper.md
- **Developed by:** [Walid](https://apify.com/dltik) (community)
- **Categories:** Business, Lead generation, Marketing
- **Stats:** 14 total users, 5 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 job scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## HelloWork Scraper — French Job Board API (800K+ Active Offers)

> Scrape **HelloWork.com**, France's #1 private job board with 800K+ active offers. Filter by keyword, city, contract type, salary range, remote policy. Get title, company, location, contract (CDI/CDD/alternance/stage), salary, remote, full description, posted date. HTTP-only, **$0.001 per job** ($1 per 1,000).

⭐ **Bookmark this HelloWork Scraper** — Apify ranks actors by bookmarks, so it directly helps the visibility of this scraper on the Apify Store.

### What is the HelloWork Scraper?

The **HelloWork Scraper** is an Apify actor that pulls live job offers from [HelloWork](https://www.hellowork.com/) — France's largest private job board, generally complementary to France Travail (which is public). HelloWork hosts 800K+ active offers across all sectors, contract types, and seniority levels. This scraper accepts complex filters (keyword, city, contract, salary, remote) and returns structured JSON with title, company, full description, salary range, posted date, application URL.

No HelloWork account, no OAuth, no quota. Pure HTTP scraping with stealth headers.

### Use cases

- **ATS feeders / job aggregators** — auto-import filtered HelloWork offers into your platform daily.
- **Salary benchmarking** — aggregate `data engineer Paris CDI` salaries across HelloWork to inform your comp band.
- **Recruitment intelligence** — track who's posting which roles in your competitive landscape.
- **Niche job board** — build a sector-specific job board (e.g., construction jobs in Auvergne) on top of HelloWork.
- **Career-services bots** — daily Telegram alert with new HelloWork jobs matching a candidate profile.
- **Labor-market analytics** — count open positions per region per sector over time.

### Input

```json
{
  "keywords": "developer python",
  "city": "Paris",
  "contractTypes": ["CDI", "Freelance"],
  "salaryMin": 45000,
  "remote": "remote_friendly",
  "limit": 200
}
````

### Output

```json
{
  "id": "HW-EXAMPLE-12345",
  "title": "Développeur Python Senior H/F",
  "company": "Example Corp",
  "city": "Paris 9e",
  "contract_type": "CDI",
  "salary_min_eur": 55000,
  "salary_max_eur": 70000,
  "remote_policy": "remote_friendly",
  "experience_required": "3-5 ans",
  "description": "Full job description text...",
  "apply_url": "https://www.hellowork.com/fr-fr/emplois/example.html",
  "posted_date": "2026-04-29"
}
```

### Pricing

**PAY\_PER\_EVENT — $0.001 per job** (= $1 per 1,000). Failed runs not charged.

### FAQ — HelloWork API alternatives

**HelloWork official API?** HelloWork doesn't expose a public job-search API. This scraper is the way to get bulk data.

**Does it cover both `hellowork.com` and the legacy `regionsjob.com`?** Yes — they merged into HelloWork; this scraper queries the unified search.

**Salary fields are often missing — why?** ~40% of French job postings don't show salary publicly. We populate `salary_min_eur` / `salary_max_eur` only when the offer states them explicitly.

**Compatible with HelloWork's `cabinet de recrutement` listings?** Yes — both direct-employer and recruitment-agency offers are returned, distinguished by the `is_agency` flag.

***

⭐ **Found this useful? Bookmark this HelloWork Scraper** — it's the strongest signal for Apify Store ranking.

#### Related actors

- [France Travail Scraper](https://apify.com/dltik/francetravail-scraper) — France's largest public job board (700K+ offers)
- [Welcome to the Jungle Scraper](https://apify.com/dltik/welcome-to-the-jungle-scraper) — tech-focused FR/EU jobs
- [JobTeaser Scraper](https://apify.com/dltik/jobteaser-scraper) — student jobs, internships, alternance

License: MIT · Author: [dltik](https://apify.com/dltik)

# Actor input Schema

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

Job search keywords (e.g. 'developpeur python', 'commercial', 'data analyst').

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

City or department (e.g. 'Paris', 'Lyon', 'Bordeaux').

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

Filter by contract: CDI, CDD, Stage, Alternance, Freelance, Interim, etc.

## `remote` (type: `string`):

Filter jobs by remote policy.

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

Filter jobs with min annual salary above this amount (€).

## `enrichDetails` (type: `boolean`):

Fetch each job page to extract full description, requirements, benefits. Slower but richer.

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

Maximum jobs per keyword. HelloWork paginates at 30 per page. Aliases accepted: 'limit', 'max'. Each result charged at the per-event price — start small to validate output.

## Actor input object example

```json
{
  "keywords": [
    "developpeur python"
  ],
  "contractTypes": [],
  "remote": "any",
  "enrichDetails": false,
  "maxResults": 20
}
```

# Actor output Schema

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

Dataset of HelloWork job postings with title, company, location, contract, salary, remote.

# 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": [
        "developpeur python"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("dltik/hellowork-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "developpeur python"
  ]
}' |
apify call dltik/hellowork-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dltik/hellowork-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HelloWork Scraper: French Job Board",
        "description": "Scrape HelloWork jobs by keyword, city, contract type, salary range. Get title, company, location, contract (CDI/CDD/alternance/stage), salary, remote policy, full description, posted date. France's #1 generalist job board. For ATS providers, recruitment agencies, sourcing teams. $1/1K jobs.",
        "version": "1.0",
        "x-build-id": "utzUUG0ajkqTjiMpA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dltik~hellowork-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dltik-hellowork-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/dltik~hellowork-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dltik-hellowork-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/dltik~hellowork-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dltik-hellowork-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Job search keywords (e.g. 'developpeur python', 'commercial', 'data analyst').",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "location": {
                        "title": "Location (optional)",
                        "type": "string",
                        "description": "City or department (e.g. 'Paris', 'Lyon', 'Bordeaux')."
                    },
                    "contractTypes": {
                        "title": "Contract types (optional)",
                        "type": "array",
                        "description": "Filter by contract: CDI, CDD, Stage, Alternance, Freelance, Interim, etc.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "remote": {
                        "title": "Remote policy (optional)",
                        "enum": [
                            "any",
                            "full",
                            "partial",
                            "occasional",
                            "no"
                        ],
                        "type": "string",
                        "description": "Filter jobs by remote policy.",
                        "default": "any"
                    },
                    "minSalary": {
                        "title": "Minimum yearly salary (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter jobs with min annual salary above this amount (€)."
                    },
                    "enrichDetails": {
                        "title": "Enrich with full job details",
                        "type": "boolean",
                        "description": "Fetch each job page to extract full description, requirements, benefits. Slower but richer.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs per keyword. HelloWork paginates at 30 per page. Aliases accepted: 'limit', 'max'. Each result charged at the per-event price — start small to validate output.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
